diff --git a/Common/GPU/D3D11/thin3d_d3d11.cpp b/Common/GPU/D3D11/thin3d_d3d11.cpp index c46012b529..5558456da8 100644 --- a/Common/GPU/D3D11/thin3d_d3d11.cpp +++ b/Common/GPU/D3D11/thin3d_d3d11.cpp @@ -1678,6 +1678,10 @@ void D3D11DrawContext::BindFramebufferAsRenderTarget(Framebuffer *fbo, const Ren if (curRenderTargetView_ == fb->colorRTView && curDepthStencilView_ == fb->depthStencilRTView) { // No need to switch, but let's fallthrough to clear! } else { + // It's not uncommon that the first slot happens to have the new render target bound as a texture, + // so unbind to make the validation layers happy. + ID3D11ShaderResourceView *empty[1] = {}; + context_->PSSetShaderResources(0, ARRAY_SIZE(empty), empty); context_->OMSetRenderTargets(1, &fb->colorRTView, fb->depthStencilRTView); curRenderTargetView_ = fb->colorRTView; curDepthStencilView_ = fb->depthStencilRTView; diff --git a/GPU/Common/FragmentShaderGenerator.cpp b/GPU/Common/FragmentShaderGenerator.cpp index 203c376b1e..dbc2c7166c 100644 --- a/GPU/Common/FragmentShaderGenerator.cpp +++ b/GPU/Common/FragmentShaderGenerator.cpp @@ -98,7 +98,6 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu bool lmode = id.Bit(FS_BIT_LMODE); bool doTexture = id.Bit(FS_BIT_DO_TEXTURE); - bool enableFog = id.Bit(FS_BIT_ENABLE_FOG); bool enableAlphaTest = id.Bit(FS_BIT_ALPHA_TEST); bool alphaTestAgainstZero = id.Bit(FS_BIT_ALPHA_AGAINST_ZERO); @@ -263,9 +262,7 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu if (doTexture && texFunc == GE_TEXFUNC_BLEND) { WRITE(p, "float3 u_texenv : register(c%i);\n", CONST_PS_TEXENV); } - if (enableFog) { - WRITE(p, "float3 u_fogcolor : register(c%i);\n", CONST_PS_FOGCOLOR); - } + WRITE(p, "float3 u_fogcolor : register(c%i);\n", CONST_PS_FOGCOLOR); if (texture3D) { WRITE(p, "float u_mipBias : register(c%i);\n", CONST_PS_MIPBIAS); } @@ -430,10 +427,8 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu WRITE(p, "%s %s lowp vec4 v_color0;\n", shading, compat.varying_fs); if (lmode) WRITE(p, "%s %s lowp vec3 v_color1;\n", shading, compat.varying_fs); - if (enableFog) { - *uniformMask |= DIRTY_FOGCOLOR; - WRITE(p, "uniform vec3 u_fogcolor;\n"); - } + *uniformMask |= DIRTY_FOGCOLOR; + WRITE(p, "uniform vec3 u_fogcolor;\n"); WRITE(p, "%s %s float v_fogdepth;\n", compat.varying_fs, highpFog ? "highp" : "mediump"); if (doTexture) { WRITE(p, "%s %s vec3 v_texcoord;\n", compat.varying_fs, highpTexcoord ? "highp" : "mediump"); @@ -541,9 +536,7 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu WRITE(p, " vec4 v_color0 = In.v_color0;\n"); if (lmode) WRITE(p, " vec3 v_color1 = In.v_color1;\n"); - if (enableFog) { - WRITE(p, " float v_fogdepth = In.v_fogdepth;\n"); - } + WRITE(p, " float v_fogdepth = In.v_fogdepth;\n"); if (doTexture) { WRITE(p, " vec3 v_texcoord = In.v_texcoord;\n"); } @@ -903,10 +896,8 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu WRITE(p, " vec4 v = v_color0 %s;\n", secondary); } - if (enableFog) { - WRITE(p, " float fogCoef = clamp(v_fogdepth, 0.0, 1.0);\n"); - WRITE(p, " v = mix(vec4(u_fogcolor, v.a), v, fogCoef);\n"); - } + WRITE(p, " float fogCoef = clamp(v_fogdepth, 0.0, 1.0);\n"); + WRITE(p, " v = mix(vec4(u_fogcolor, v.a), v, fogCoef);\n"); // Texture access is at half texels [0.5/256, 255.5/256], but colors are normalized [0, 255]. // So we have to scale to account for the difference. diff --git a/GPU/Common/ShaderCommon.h b/GPU/Common/ShaderCommon.h index 6a955513cf..e715936ddd 100644 --- a/GPU/Common/ShaderCommon.h +++ b/GPU/Common/ShaderCommon.h @@ -45,7 +45,7 @@ enum : uint64_t { DIRTY_PROJMATRIX = 1ULL << 0, DIRTY_PROJTHROUGHMATRIX = 1ULL << 1, DIRTY_FOGCOLOR = 1ULL << 2, - DIRTY_FOGCOEF = 1ULL << 3, + DIRTY_FOGCOEFENABLE = 1ULL << 3, DIRTY_TEXENV = 1ULL << 4, DIRTY_ALPHACOLORREF = 1ULL << 5, diff --git a/GPU/Common/ShaderId.cpp b/GPU/Common/ShaderId.cpp index d70166e0aa..d11cac5859 100644 --- a/GPU/Common/ShaderId.cpp +++ b/GPU/Common/ShaderId.cpp @@ -190,7 +190,6 @@ std::string FragmentShaderDesc(const FShaderID &id) { if (id.Bit(FS_BIT_TEXALPHA)) desc << "TexAlpha "; if (id.Bit(FS_BIT_TEXTURE_AT_OFFSET)) desc << "TexOffs "; if (id.Bit(FS_BIT_LMODE)) desc << "LM "; - if (id.Bit(FS_BIT_ENABLE_FOG)) desc << "Fog "; if (id.Bit(FS_BIT_COLOR_DOUBLE)) desc << "2x "; if (id.Bit(FS_BIT_FLATSHADE)) desc << "Flat "; if (id.Bit(FS_BIT_BGRA_TEXTURE)) desc << "BGRA "; @@ -340,7 +339,6 @@ void ComputeFragmentShaderID(FShaderID *id_out, const ComputedPipelineState &pip id.SetBit(FS_BIT_TEST_DISCARD_TO_ZERO, !NeedsTestDiscard()); } - id.SetBit(FS_BIT_ENABLE_FOG, enableFog); id.SetBit(FS_BIT_DO_TEXTURE_PROJ, doTextureProjection); id.SetBit(FS_BIT_COLOR_DOUBLE, enableColorDoubling); diff --git a/GPU/Common/ShaderId.h b/GPU/Common/ShaderId.h index d98c1fb6a3..f71eee7555 100644 --- a/GPU/Common/ShaderId.h +++ b/GPU/Common/ShaderId.h @@ -81,7 +81,7 @@ enum FShaderBit : uint8_t { FS_BIT_COLOR_TEST = 17, FS_BIT_COLOR_TEST_FUNC = 18, // 2 bits FS_BIT_COLOR_AGAINST_ZERO = 20, - FS_BIT_ENABLE_FOG = 21, + // 1 free bit FS_BIT_DO_TEXTURE_PROJ = 22, FS_BIT_COLOR_DOUBLE = 23, FS_BIT_STENCIL_TO_ALPHA = 24, // 2 bits diff --git a/GPU/Common/ShaderUniforms.cpp b/GPU/Common/ShaderUniforms.cpp index 0e88b89300..17229c540e 100644 --- a/GPU/Common/ShaderUniforms.cpp +++ b/GPU/Common/ShaderUniforms.cpp @@ -174,21 +174,28 @@ void BaseUpdateUniforms(UB_VS_FS_Base *ub, uint64_t dirtyUniforms, bool flipView ConvertMatrix4x3To3x4Transposed(ub->tex, gstate.tgenMatrix); } - if (dirtyUniforms & DIRTY_FOGCOEF) { - float fogcoef[2] = { - getFloat24(gstate.fog1), - getFloat24(gstate.fog2), - }; - // The PSP just ignores infnan here (ignoring IEEE), so take it down to a valid float. - // Workaround for https://github.com/hrydgard/ppsspp/issues/5384#issuecomment-38365988 - if (my_isnanorinf(fogcoef[0])) { - // Not really sure what a sensible value might be, but let's try 64k. - fogcoef[0] = std::signbit(fogcoef[0]) ? -65535.0f : 65535.0f; + if (dirtyUniforms & DIRTY_FOGCOEFENABLE) { + if (gstate.isFogEnabled() && !gstate.isModeThrough()) { + float fogcoef[2] = { + getFloat24(gstate.fog1), + getFloat24(gstate.fog2), + }; + // The PSP just ignores infnan here (ignoring IEEE), so take it down to a valid float. + // Workaround for https://github.com/hrydgard/ppsspp/issues/5384#issuecomment-38365988 + if (my_isnanorinf(fogcoef[0])) { + // Not really sure what a sensible value might be, but let's try 64k. + fogcoef[0] = std::signbit(fogcoef[0]) ? -65535.0f : 65535.0f; + } + if (my_isnanorinf(fogcoef[1])) { + fogcoef[1] = std::signbit(fogcoef[1]) ? -65535.0f : 65535.0f; + } + CopyFloat2(ub->fogCoef, fogcoef); + } else { + // not very useful values, use as marker for disabled fog. + // could also burn one extra uniform. + ub->fogCoef[0] = -65536.0f; + ub->fogCoef[1] = -65536.0f; } - if (my_isnanorinf(fogcoef[1])) { - fogcoef[1] = std::signbit(fogcoef[1]) ? -65535.0f : 65535.0f; - } - CopyFloat2(ub->fogCoef, fogcoef); } if (dirtyUniforms & DIRTY_STENCILREPLACEVALUE) { diff --git a/GPU/Common/ShaderUniforms.h b/GPU/Common/ShaderUniforms.h index 40b1ce339a..52e49acdb7 100644 --- a/GPU/Common/ShaderUniforms.h +++ b/GPU/Common/ShaderUniforms.h @@ -9,7 +9,7 @@ enum : uint64_t { DIRTY_BASE_UNIFORMS = DIRTY_WORLDMATRIX | DIRTY_PROJTHROUGHMATRIX | DIRTY_VIEWMATRIX | DIRTY_TEXMATRIX | DIRTY_ALPHACOLORREF | - DIRTY_PROJMATRIX | DIRTY_FOGCOLOR | DIRTY_FOGCOEF | DIRTY_TEXENV | DIRTY_STENCILREPLACEVALUE | + DIRTY_PROJMATRIX | DIRTY_FOGCOLOR | DIRTY_TEXENV | DIRTY_STENCILREPLACEVALUE | DIRTY_ALPHACOLORMASK | DIRTY_SHADERBLEND | DIRTY_COLORWRITEMASK | DIRTY_UVSCALEOFFSET | DIRTY_TEXCLAMP | DIRTY_DEPTHRANGE | DIRTY_MATAMBIENTALPHA | DIRTY_BEZIERSPLINE | DIRTY_DEPAL, DIRTY_LIGHT_UNIFORMS = diff --git a/GPU/Common/SoftwareTransformCommon.cpp b/GPU/Common/SoftwareTransformCommon.cpp index 489e67bf9b..7270cd9b2a 100644 --- a/GPU/Common/SoftwareTransformCommon.cpp +++ b/GPU/Common/SoftwareTransformCommon.cpp @@ -241,9 +241,11 @@ void SoftwareTransform::Decode(int prim, u32 vertType, const DecVtxFormat &decVt // Ignore color1 and fog, never used in throughmode anyway. // The w of uv is also never used (hardcoded to 1.0.) + vert.fog = 1.0; } } else { const Vec4f materialAmbientRGBA = Vec4f::FromRGBA(gstate.getMaterialAmbientRGBA()); + bool fogEnabled = gstate.isFogEnabled(); // Okay, need to actually perform the full transform. for (int index = 0; index < maxIndex; index++) { reader.Goto(index); @@ -252,7 +254,6 @@ void SoftwareTransform::Decode(int prim, u32 vertType, const DecVtxFormat &decVt Vec4f c0 = Vec4f(1, 1, 1, 1); Vec4f c1 = Vec4f(0, 0, 0, 0); float uv[3] = {0, 0, 1}; - float fogCoef = 1.0f; float out[3]; float pos[3]; @@ -414,11 +415,10 @@ void SoftwareTransform::Decode(int prim, u32 vertType, const DecVtxFormat &decVt // Transform the coord by the view matrix. Vec3ByMatrix43(v, out, gstate.viewMatrix); - fogCoef = (v[2] + fog_end) * fog_slope; // TODO: Write to a flexible buffer, we don't always need all four components. Vec3ByMatrix44(transformed[index].pos, v, projMatrix_.m); - transformed[index].fog = fogCoef; + transformed[index].fog = fogEnabled ? (v[2] + fog_end) * fog_slope : 1.0f; memcpy(&transformed[index].uv, uv, 3 * sizeof(float)); transformed[index].color0_32 = c0.ToRGBA(); transformed[index].color1_32 = c1.ToRGBA(); diff --git a/GPU/Common/VertexShaderGenerator.cpp b/GPU/Common/VertexShaderGenerator.cpp index d0160bbad0..504c854d46 100644 --- a/GPU/Common/VertexShaderGenerator.cpp +++ b/GPU/Common/VertexShaderGenerator.cpp @@ -585,7 +585,7 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag *uniformMask |= DIRTY_MATAMBIENTALPHA; } WRITE(p, "uniform highp vec2 u_fogcoef;\n"); - *uniformMask |= DIRTY_FOGCOEF; + *uniformMask |= DIRTY_FOGCOEFENABLE; if (!isModeThrough) { WRITE(p, "uniform highp vec4 u_depthRange;\n"); @@ -1277,7 +1277,11 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag } // Compute fogdepth - WRITE(p, " %sv_fogdepth = (viewPos.z + u_fogcoef.x) * u_fogcoef.y;\n", compat.vsOutPrefix); + WRITE(p, " if (u_fogcoef.x <= -65535.0 && u_fogcoef.y <= -65535.0) {\n"); + WRITE(p, " %sv_fogdepth = (viewPos.z + u_fogcoef.x) * u_fogcoef.y;\n", compat.vsOutPrefix); + WRITE(p, " } else {\n"); + WRITE(p, " %sv_fogdepth = 1.0;\n", compat.vsOutPrefix); + WRITE(p, " }\n"); } if (clipClampedDepth) { diff --git a/GPU/Directx9/ShaderManagerDX9.cpp b/GPU/Directx9/ShaderManagerDX9.cpp index dc9a81a250..1f820310bd 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_FOGCOEFENABLE | DIRTY_BONE_UNIFORMS | 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) { @@ -371,21 +371,27 @@ void ShaderManagerDX9::VSUpdateUniforms(u64 dirtyUniforms) { if (dirtyUniforms & DIRTY_TEXMATRIX) { VSSetMatrix4x3_3(CONST_VS_TEXMTX, gstate.tgenMatrix); } - if (dirtyUniforms & DIRTY_FOGCOEF) { - float fogcoef[2] = { - getFloat24(gstate.fog1), - getFloat24(gstate.fog2), - }; - // The PSP just ignores infnan here (ignoring IEEE), so take it down to a valid float. - // Workaround for https://github.com/hrydgard/ppsspp/issues/5384#issuecomment-38365988 - if (my_isnanorinf(fogcoef[0])) { - // Not really sure what a sensible value might be, but let's try 64k. - fogcoef[0] = std::signbit(fogcoef[0]) ? -65535.0f : 65535.0f; + if (dirtyUniforms & DIRTY_FOGCOEFENABLE) { + if (gstate.isFogEnabled() && !gstate.isModeThrough()) { + float fogcoef[2] = { + getFloat24(gstate.fog1), + getFloat24(gstate.fog2), + }; + // The PSP just ignores infnan here (ignoring IEEE), so take it down to a valid float. + // Workaround for https://github.com/hrydgard/ppsspp/issues/5384#issuecomment-38365988 + if (my_isnanorinf(fogcoef[0])) { + // Not really sure what a sensible value might be, but let's try 64k. + fogcoef[0] = std::signbit(fogcoef[0]) ? -65535.0f : 65535.0f; + } + if (my_isnanorinf(fogcoef[1])) { + fogcoef[1] = std::signbit(fogcoef[1]) ? -65535.0f : 65535.0f; + } + VSSetFloatArray(CONST_VS_FOGCOEF, fogcoef, 2); + } else { + // not very useful values, use as marker for disabled fog. + float fogcoef[2] = { -65536.0f, -65536.0f }; + VSSetFloatArray(CONST_VS_FOGCOEF, fogcoef, 2); } - if (my_isnanorinf(fogcoef[1])) { - fogcoef[1] = std::signbit(fogcoef[1]) ? -65535.0f : 65535.0f; - } - VSSetFloatArray(CONST_VS_FOGCOEF, fogcoef, 2); } // TODO: Could even set all bones in one go if they're all dirty. #ifdef USE_BONE_ARRAY diff --git a/GPU/GLES/ShaderManagerGLES.cpp b/GPU/GLES/ShaderManagerGLES.cpp index 3524b6f2ff..80713cb14b 100644 --- a/GPU/GLES/ShaderManagerGLES.cpp +++ b/GPU/GLES/ShaderManagerGLES.cpp @@ -455,21 +455,26 @@ void LinkedShader::UpdateUniforms(const ShaderID &vsid, bool useBufferedRenderin SetVRCompat(VR_COMPAT_FOG_COLOR, gstate.fogcolor); } } - if (dirty & DIRTY_FOGCOEF) { - float fogcoef[2] = { - getFloat24(gstate.fog1), - getFloat24(gstate.fog2), - }; - // The PSP just ignores infnan here (ignoring IEEE), so take it down to a valid float. - // Workaround for https://github.com/hrydgard/ppsspp/issues/5384#issuecomment-38365988 - if (my_isnanorinf(fogcoef[0])) { - // Not really sure what a sensible value might be, but let's try 64k. - fogcoef[0] = std::signbit(fogcoef[0]) ? -65535.0f : 65535.0f; + if (dirty & DIRTY_FOGCOEFENABLE) { + if (gstate.isFogEnabled() && !gstate.isModeThrough()) { + float fogcoef[2] = { + getFloat24(gstate.fog1), + getFloat24(gstate.fog2), + }; + // The PSP just ignores infnan here (ignoring IEEE), so take it down to a valid float. + // Workaround for https://github.com/hrydgard/ppsspp/issues/5384#issuecomment-38365988 + if (my_isnanorinf(fogcoef[0])) { + // Not really sure what a sensible value might be, but let's try 64k. + fogcoef[0] = std::signbit(fogcoef[0]) ? -65535.0f : 65535.0f; + } + if (my_isnanorinf(fogcoef[1])) { + fogcoef[1] = std::signbit(fogcoef[1]) ? -65535.0f : 65535.0f; + } + render_->SetUniformF(&u_fogcoef, 2, fogcoef); + } else { + float fogcoef[2] = { -65536.0f, -65536.0f }; + render_->SetUniformF(&u_fogcoef, 2, fogcoef); } - if (my_isnanorinf(fogcoef[1])) { - fogcoef[1] = std::signbit(fogcoef[1]) ? -65535.0f : 65535.0f; - } - render_->SetUniformF(&u_fogcoef, 2, fogcoef); } if (dirty & DIRTY_UVSCALEOFFSET) { const float invW = 1.0f / (float)gstate_c.curTextureWidth; @@ -933,7 +938,7 @@ std::string ShaderManagerGLES::DebugGetShaderString(std::string id, DebugShaderT // as sometimes these features might have an effect on the ID bits. #define CACHE_HEADER_MAGIC 0x83277592 -#define CACHE_VERSION 17 +#define CACHE_VERSION 18 struct CacheHeader { uint32_t magic; uint32_t version; diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index a1c205cfdc..ad01665155 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -83,13 +83,13 @@ const CommonCommandTableEntry commonCommandTable[] = { { GE_CMD_ZBUFWIDTH, FLAG_FLUSHBEFOREONCHANGE }, { GE_CMD_FOGCOLOR, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOLOR }, - { GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF }, - { GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEF }, + { GE_CMD_FOG1, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEFENABLE }, + { GE_CMD_FOG2, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEFENABLE }, // These affect the fragment shader so need flushing. { GE_CMD_CLEARMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_BLEND_STATE | DIRTY_DEPTHSTENCIL_STATE | DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_CULLRANGE | DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE }, { GE_CMD_TEXTUREMAPENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE }, - { GE_CMD_FOGENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FRAGMENTSHADER_STATE }, + { GE_CMD_FOGENABLE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_FOGCOEFENABLE }, { GE_CMD_TEXMODE, FLAG_FLUSHBEFOREONCHANGE, DIRTY_TEXTURE_PARAMS | DIRTY_FRAGMENTSHADER_STATE }, { GE_CMD_TEXSHADELS, FLAG_FLUSHBEFOREONCHANGE, DIRTY_VERTEXSHADER_STATE }, // Raster state for Direct3D 9, uncommon. @@ -1751,8 +1751,9 @@ void GPUCommon::Execute_VertexType(u32 op, u32 diff) { gstate_c.Dirty(DIRTY_VERTEXSHADER_STATE); if (diff & (GE_VTYPE_TC_MASK | GE_VTYPE_THROUGH_MASK)) { gstate_c.Dirty(DIRTY_UVSCALEOFFSET); + // Switching between through and non-through, we need to invalidate a bunch of stuff. if (diff & GE_VTYPE_THROUGH_MASK) - gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE | DIRTY_CULLRANGE); + gstate_c.Dirty(DIRTY_RASTER_STATE | DIRTY_VIEWPORTSCISSOR_STATE | DIRTY_FRAGMENTSHADER_STATE | DIRTY_GEOMETRYSHADER_STATE | DIRTY_CULLRANGE | DIRTY_FOGCOEFENABLE); } } diff --git a/GPU/Vulkan/ShaderManagerVulkan.cpp b/GPU/Vulkan/ShaderManagerVulkan.cpp index 7c4a0bf59b..3d6fd307fb 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.cpp +++ b/GPU/Vulkan/ShaderManagerVulkan.cpp @@ -499,7 +499,7 @@ VulkanGeometryShader *ShaderManagerVulkan::GetGeometryShaderFromModule(VkShaderM // instantaneous. #define CACHE_HEADER_MAGIC 0xff51f420 -#define CACHE_VERSION 32 +#define CACHE_VERSION 33 struct VulkanCacheHeader { uint32_t magic; uint32_t version;