Remove duplicated uniforms in accurate texture coordinate path.

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilder.h

@@ -67,6 +67,10 @@ public:
 	static u32 s_cycleType;
 	static TextureConvert s_textureConvert;
 
+protected:
+	virtual const ShaderPart * getVertexShaderTexturedRect() const = 0;
+	virtual const ShaderPart * getVertexShaderTexturedTriangle() const = 0;
+
 private:
 	CombinerInputs compileCombiner(const CombinerKey & _key, Combiner & _color, Combiner & _alpha, std::string & _strShader);
 

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilderAccurate.cpp

@@ -31,8 +31,7 @@ public:
 			"uniform mediump vec2 uAdjustTrans;					\n"
 			"uniform mediump vec2 uAdjustScale;					\n"
 			"uniform lowp ivec2 uCacheFrameBuffer;				\n"
-			"OUT highp vec2 vTexCoord0;							\n"
+			"OUT highp vec2 vTexCoord;							\n"
-			"OUT highp vec2 vTexCoord1;							\n"
 			"OUT mediump vec2 vLodTexCoord;						\n"
 			"OUT lowp float vNumLights;							\n"
 			"OUT lowp vec4 vShadeColor;							\n"
@@ -50,8 +49,7 @@ public:
 			"  vec2 texCoord = aTexCoord;									\n"
 			"  texCoord *= uTexScale;										\n"
 			"  if (uTexturePersp == 0 && aModify[2] == 0.0) texCoord *= 0.5;\n"
-			"  vTexCoord0 = texCoord;										\n"
+			"  vTexCoord = texCoord;										\n"
-			"  vTexCoord1 = texCoord;										\n"
 			"  vLodTexCoord = texCoord;										\n"
 			"  vNumLights = aNumLights;										\n"
 			"  if ((aModify[0]) != 0.0) {									\n"
@@ -84,6 +82,51 @@ public:
 	}
 };
 
+class VertexShaderTexturedRect : public ShaderPart
+{
+public:
+	VertexShaderTexturedRect(const opengl::GLInfo & _glinfo)
+	{
+		m_part =
+			"IN highp vec4 aRectPosition;						\n"
+			"IN highp vec2 aTexCoord0;							\n"
+			"IN highp vec2 aTexCoord1;							\n"
+			"IN highp vec2 aBaryCoords;							\n"
+			"													\n"
+			"OUT highp vec2 vTexCoord;							\n"
+			"OUT lowp vec4 vShadeColor;							\n"
+			"OUT highp vec4 vBaryCoords;						\n"
+			;
+		if (!_glinfo.isGLESX || _glinfo.noPerspective)
+			m_part += "noperspective OUT lowp vec4 vShadeColorNoperspective;\n";
+		else
+			m_part += "OUT lowp vec4 vShadeColorNoperspective;				\n";
+		m_part +=
+			"uniform lowp vec4 uRectColor;						\n"
+			"void main()										\n"
+			"{													\n"
+			"  gl_Position = aRectPosition;						\n"
+			"  vShadeColor = uRectColor;						\n"
+			"  vShadeColorNoperspective = uRectColor;			\n"
+			"  vTexCoord = aTexCoord0;							\n"
+			"  vBaryCoords = vec4(aBaryCoords, vec2(1.0) - aBaryCoords);	\n"
+			;
+	}
+};
+
+class ShaderFragmentCorrectTexCoords : public ShaderPart {
+public:
+	ShaderFragmentCorrectTexCoords() {
+		m_part +=
+			" highp vec2 mTexCoord = vTexCoord + vec2(0.0001);						\n"
+			" mTexCoord += uTexCoordOffset;											\n"
+			" if (uUseTexCoordBounds != 0)											\n"
+			" mTexCoord = clamp(mTexCoord, uTexCoordBounds.xy, uTexCoordBounds.zw);	\n"
+			"																		\n"
+			;
+	}
+};
+
 class ShaderFragmentGlobalVariablesTex : public ShaderPart
 {
 public:
@@ -120,12 +163,11 @@ public:
 			"uniform highp vec2 uShiftScale[2];		\n"
 			"uniform highp vec2 uTexOffset[2];		\n"
 			"uniform highp vec2 uHDRatio[2];		\n"
-			"uniform highp vec2 uTexCoordOffset[2];	\n"
+			"uniform highp vec2 uTexCoordOffset;	\n"
 			"uniform highp vec2 uBilinearOffset;	\n"
 			"uniform highp vec2 uCacheOffset[2];	\n"
 			"uniform lowp int uUseTexCoordBounds;	\n"
-			"uniform highp vec4 uTexCoordBounds0;	\n"
+			"uniform highp vec4 uTexCoordBounds;	\n"
-			"uniform highp vec4 uTexCoordBounds1;	\n"
 			"uniform lowp int uScreenSpaceTriangle;	\n"
 			"highp vec2 texCoord0;					\n"
 			"highp vec2 texCoord1;					\n"
@@ -181,8 +223,7 @@ public:
 
 		m_part +=
 			"IN lowp vec4 vShadeColor;		\n"
-			"IN highp vec2 vTexCoord0;		\n"
+			"IN highp vec2 vTexCoord;		\n"
-			"IN highp vec2 vTexCoord1;		\n"
 			"IN mediump vec2 vLodTexCoord;	\n"
 			"IN lowp float vNumLights;		\n"
 			"IN highp vec4 vBaryCoords;		\n"
@@ -1136,7 +1177,7 @@ public:
 	ShaderFragmentTextureEngineTex0(const opengl::GLInfo _glinfo)
 	{
 		m_part =
-			"textureEngine0(mTexCoord0, tcData0); \n"
+			"textureEngine0(mTexCoord, tcData0); \n"
 			;
 	}
 };
@@ -1146,7 +1187,7 @@ public:
 	ShaderFragmentTextureEngineTex1(const opengl::GLInfo _glinfo)
 	{
 		m_part =
-			"textureEngine1(mTexCoord1, tcData1); \n"
+			"textureEngine1(mTexCoord, tcData1); \n"
 			;
 	}
 };
@@ -1156,8 +1197,10 @@ public:
 namespace glsl {
 
 CombinerProgramBuilderAccurate::CombinerProgramBuilderAccurate(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram)
-: CombinerProgramBuilderCommon(_glinfo, _useProgram, std::make_unique<CombinerProgramUniformFactoryAccurate>(_glinfo),
+: CombinerProgramBuilderCommon(_glinfo, _useProgram, std::make_unique<CombinerProgramUniformFactoryAccurate>(_glinfo))
-	   std::make_unique<VertexShaderTexturedTriangle>(_glinfo))
+, m_vertexTexturedTriangle(new VertexShaderTexturedTriangle(_glinfo))
+, m_vertexTexturedRect(new VertexShaderTexturedRect(_glinfo))
+, m_fragmentCorrectTexCoords(new ShaderFragmentCorrectTexCoords())
 , m_fragmentGlobalVariablesTex(new ShaderFragmentGlobalVariablesTex(_glinfo))
 , m_fragmentHeaderTextureEngine(new ShaderFragmentHeaderTextureEngine(_glinfo))
 , m_fragmentHeaderReadMSTex(new ShaderFragmentHeaderReadMSTex(_glinfo))
@@ -1175,6 +1218,21 @@ CombinerProgramBuilderAccurate::CombinerProgramBuilderAccurate(const opengl::GLI
 {
 }
 
+const ShaderPart * CombinerProgramBuilderAccurate::getVertexShaderTexturedRect() const
+{
+	return m_vertexTexturedRect.get();
+}
+
+const ShaderPart * CombinerProgramBuilderAccurate::getVertexShaderTexturedTriangle() const
+{
+	return m_vertexTexturedTriangle.get();
+}
+
+void CombinerProgramBuilderAccurate::_writeFragmentCorrectTexCoords(std::stringstream& ssShader)const
+{
+	m_fragmentCorrectTexCoords->write(ssShader);
+}
+
 void CombinerProgramBuilderAccurate::_writeFragmentGlobalVariablesTex(std::stringstream& ssShader) const
 {
 	m_fragmentGlobalVariablesTex->write(ssShader);

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilderAccurate.h

@@ -9,6 +9,10 @@ public:
 	CombinerProgramBuilderAccurate(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram);
 
 private:
+	const ShaderPart * getVertexShaderTexturedRect() const override;
+	const ShaderPart * getVertexShaderTexturedTriangle() const override;
+
+	void _writeFragmentCorrectTexCoords(std::stringstream& ssShader) const override;
 	void _writeFragmentGlobalVariablesTex(std::stringstream& ssShader) const override;
 	void _writeFragmentHeaderReadMSTex(std::stringstream& ssShader) const override;
 	void _writeFragmentHeaderReadTex(std::stringstream& ssShader) const override;
@@ -24,6 +28,9 @@ private:
 	void _writeShaderReadtex(std::stringstream& ssShader) const override;
 	void _writeShaderReadtexCopyMode(std::stringstream& ssShader) const override;
 
+	ShaderPartPtr m_vertexTexturedTriangle;
+	ShaderPartPtr m_vertexTexturedRect;
+	ShaderPartPtr m_fragmentCorrectTexCoords;
 	ShaderPartPtr m_fragmentGlobalVariablesTex;
 	ShaderPartPtr m_fragmentHeaderTextureEngine;
 	ShaderPartPtr m_fragmentHeaderReadMSTex;

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilderCommon.cpp

@@ -124,40 +124,6 @@ public:
 	}
 };
 
-class VertexShaderTexturedRect : public ShaderPart
-{
-public:
-	VertexShaderTexturedRect(const opengl::GLInfo & _glinfo)
-	{
-		m_part =
-			"IN highp vec4 aRectPosition;						\n"
-			"IN highp vec2 aTexCoord0;							\n"
-			"IN highp vec2 aTexCoord1;							\n"
-			"IN highp vec2 aBaryCoords;							\n"
-			"													\n"
-			"OUT highp vec2 vTexCoord0;							\n"
-			"OUT highp vec2 vTexCoord1;							\n"
-			"OUT lowp vec4 vShadeColor;							\n"
-			"OUT highp vec4 vBaryCoords;						\n"
-			;
-		if (!_glinfo.isGLESX || _glinfo.noPerspective)
-			m_part += "noperspective OUT lowp vec4 vShadeColorNoperspective;\n";
-		else
-			m_part += "OUT lowp vec4 vShadeColorNoperspective;				\n";
-		m_part +=
-			"uniform lowp vec4 uRectColor;						\n"
-			"void main()										\n"
-			"{													\n"
-			"  gl_Position = aRectPosition;						\n"
-			"  vShadeColor = uRectColor;						\n"
-			"  vShadeColorNoperspective = uRectColor;			\n"
-			"  vTexCoord0 = aTexCoord0;							\n"
-			"  vTexCoord1 = aTexCoord1;							\n"
-			"  vBaryCoords = vec4(aBaryCoords, vec2(1.0) - aBaryCoords);	\n"
-			;
-	}
-};
-
 class VertexShaderRect : public ShaderPart
 {
 public:
@@ -1356,22 +1322,6 @@ public:
 	}
 };
 
-class ShaderFragmentCorrectTexCoords : public ShaderPart {
-public:
-	ShaderFragmentCorrectTexCoords() {
-		m_part +=
-			" highp vec2 mTexCoord0 = vTexCoord0 + vec2(0.0001);						\n"
-			" highp vec2 mTexCoord1 = vTexCoord1 + vec2(0.0001);						\n"
-			" mTexCoord0 += uTexCoordOffset[0];											\n"
-			" mTexCoord1 += uTexCoordOffset[1];											\n"
-			" if (uUseTexCoordBounds != 0) {											\n"
-			" mTexCoord0 = clamp(mTexCoord0, uTexCoordBounds0.xy, uTexCoordBounds0.zw); \n"
-			" mTexCoord1 = clamp(mTexCoord1, uTexCoordBounds1.xy, uTexCoordBounds1.zw); \n"
-			" }																			\n"
-			;
-	}
-};
-
 class ShaderCoverage : public ShaderPart {
 public:
 	ShaderCoverage() {
@@ -1394,7 +1344,7 @@ public:
 /*---------------ShaderPartsEnd-------------*/
 
 static
-GLuint _createVertexShader(ShaderPart * _header, ShaderPart * _body, ShaderPart * _footer)
+GLuint _createVertexShader(const ShaderPart* _header, const ShaderPart* _body, const ShaderPart* _footer)
 {
 	std::stringstream ssShader;
 	_header->write(ssShader);
@@ -1416,8 +1366,7 @@ GLuint _createVertexShader(ShaderPart * _header, ShaderPart * _body, ShaderPart
 namespace glsl {
 
 CombinerProgramBuilderCommon::CombinerProgramBuilderCommon(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram,
-	std::unique_ptr<CombinerProgramUniformFactory> _uniformFactory,
+	std::unique_ptr<CombinerProgramUniformFactory> _uniformFactory)
-	std::unique_ptr<ShaderPart> _vertexTexturedTriangle)
 : CombinerProgramBuilder(_glinfo, _useProgram, std::move(_uniformFactory))
 , m_blender1(new ShaderBlender1(_glinfo))
 , m_blender2(new ShaderBlender2(_glinfo))
@@ -1433,7 +1382,6 @@ CombinerProgramBuilderCommon::CombinerProgramBuilderCommon(const opengl::GLInfo
 , m_vertexHeader(new VertexShaderHeader(_glinfo))
 , m_vertexEnd(new VertexShaderEnd(_glinfo))
 , m_vertexRect(new VertexShaderRect(_glinfo))
-, m_vertexTexturedRect(new VertexShaderTexturedRect(_glinfo))
 , m_vertexTriangle(new VertexShaderTriangle(_glinfo))
 , m_fragmentHeader(new FragmentShaderHeader(_glinfo))
 , m_fragmentGlobalVariablesNotex(new ShaderFragmentGlobalVariablesNotex(_glinfo))
@@ -1446,7 +1394,6 @@ CombinerProgramBuilderCommon::CombinerProgramBuilderCommon(const opengl::GLInfo
 , m_fragmentMain(new ShaderFragmentMain(_glinfo))
 , m_fragmentMain2Cycle(new ShaderFragmentMain2Cycle(_glinfo))
 , m_fragmentBlendMux(new ShaderFragmentBlendMux(_glinfo))
-, m_fragmentCorrectTexCoords(new ShaderFragmentCorrectTexCoords())
 , m_fragmentReadTexMipmap(new ShaderFragmentReadTexMipmap(_glinfo))
 , m_fragmentCallN64Depth(new ShaderFragmentCallN64Depth(_glinfo))
 , m_fragmentRenderTarget(new ShaderFragmentRenderTarget(_glinfo))
@@ -1460,10 +1407,6 @@ CombinerProgramBuilderCommon::CombinerProgramBuilderCommon(const opengl::GLInfo
 , m_shaderCoverage(new ShaderCoverage())
 , m_combinerOptionsBits(graphics::CombinerProgram::getShaderCombinerOptionsBits())
 {
-	m_vertexShaderRect = _createVertexShader(m_vertexHeader.get(), m_vertexRect.get(), m_vertexEnd.get());
-	m_vertexShaderTriangle = _createVertexShader(m_vertexHeader.get(), m_vertexTriangle.get(), m_vertexEnd.get());
-	m_vertexShaderTexturedRect = _createVertexShader(m_vertexHeader.get(), m_vertexTexturedRect.get(), m_vertexEnd.get());
-	m_vertexShaderTexturedTriangle = _createVertexShader(m_vertexHeader.get(), _vertexTexturedTriangle.get(), m_vertexEnd.get());
 }
 
 CombinerProgramBuilderCommon::~CombinerProgramBuilderCommon()
@@ -1496,21 +1439,29 @@ bool CombinerProgramBuilderCommon::isObsolete() const
 
 GLuint CombinerProgramBuilderCommon::_getVertexShaderRect() const
 {
+	if (m_vertexShaderRect == 0)
+		m_vertexShaderRect = _createVertexShader(m_vertexHeader.get(), m_vertexRect.get(), m_vertexEnd.get());
 	return m_vertexShaderRect;
 }
 
 GLuint CombinerProgramBuilderCommon::_getVertexShaderTriangle() const
 {
+	if (m_vertexShaderTriangle == 0)
+		m_vertexShaderTriangle = _createVertexShader(m_vertexHeader.get(), m_vertexTriangle.get(), m_vertexEnd.get());
 	return m_vertexShaderTriangle;
 }
 
 GLuint CombinerProgramBuilderCommon::_getVertexShaderTexturedRect() const
 {
+	if (m_vertexShaderTexturedRect == 0)
+		m_vertexShaderTexturedRect = _createVertexShader(m_vertexHeader.get(), getVertexShaderTexturedRect(), m_vertexEnd.get());
 	return m_vertexShaderTexturedRect;
 }
 
 GLuint CombinerProgramBuilderCommon::_getVertexShaderTexturedTriangle() const
 {
+	if (m_vertexShaderTexturedTriangle == 0)
+		m_vertexShaderTexturedTriangle = _createVertexShader(m_vertexHeader.get(), getVertexShaderTexturedTriangle(), m_vertexEnd.get());
 	return m_vertexShaderTexturedTriangle;
 }
 
@@ -1629,11 +1580,6 @@ void CombinerProgramBuilderCommon::_writeShaderCoverage(std::stringstream& ssSha
 	 m_shaderCoverage->write(ssShader);
 }
 
-void CombinerProgramBuilderCommon::_writeFragmentCorrectTexCoords(std::stringstream& ssShader)const
-{
-	 m_fragmentCorrectTexCoords->write(ssShader);
-}
-
 void CombinerProgramBuilderCommon::_writeFragmentReadTexMipmap(std::stringstream& ssShader)const
 {
 	 m_fragmentReadTexMipmap->write(ssShader);

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilderCommon.h

@@ -7,8 +7,7 @@ class CombinerProgramBuilderCommon : public glsl::CombinerProgramBuilder
 {
 public:
 	CombinerProgramBuilderCommon(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram,
-		std::unique_ptr<CombinerProgramUniformFactory> _uniformFactory,
+		std::unique_ptr<CombinerProgramUniformFactory> _uniformFactory);
-		std::unique_ptr<ShaderPart> _vertexTexturedTriangle);
 	~CombinerProgramBuilderCommon();
 
 	const ShaderPart * getVertexShaderHeader() const override;
@@ -49,7 +48,6 @@ private:
 	void _writeFragmentMain(std::stringstream& ssShader) const override;
 	void _writeFragmentBlendMux(std::stringstream& ssShader) const override;
 	void _writeShaderCoverage(std::stringstream& ssShader) const override;
-	void _writeFragmentCorrectTexCoords(std::stringstream& ssShader) const override;
 	void _writeFragmentReadTexMipmap(std::stringstream& ssShader) const override;
 	void _writeFragmentCallN64Depth(std::stringstream& ssShader) const override;
 	void _writeFragmentRenderTarget(std::stringstream& ssShader) const override;
@@ -76,7 +74,6 @@ private:
 	ShaderPartPtr m_vertexHeader;
 	ShaderPartPtr m_vertexEnd;
 	ShaderPartPtr m_vertexRect;
-	ShaderPartPtr m_vertexTexturedRect;
 	ShaderPartPtr m_vertexTriangle;
 
 	ShaderPartPtr m_fragmentHeader;
@@ -90,7 +87,6 @@ private:
 	ShaderPartPtr m_fragmentMain;
 	ShaderPartPtr m_fragmentMain2Cycle;
 	ShaderPartPtr m_fragmentBlendMux;
-	ShaderPartPtr m_fragmentCorrectTexCoords;
 	ShaderPartPtr m_fragmentReadTexMipmap;
 	ShaderPartPtr m_fragmentCallN64Depth;
 	ShaderPartPtr m_fragmentRenderTarget;
@@ -106,10 +102,10 @@ private:
 
 	u32 m_combinerOptionsBits;
 
-	GLuint m_vertexShaderRect;
+	mutable GLuint m_vertexShaderRect = 0u;
-	GLuint m_vertexShaderTriangle;
+	mutable GLuint m_vertexShaderTriangle = 0u;
-	GLuint m_vertexShaderTexturedRect;
+	mutable GLuint m_vertexShaderTexturedRect = 0u;
-	GLuint m_vertexShaderTexturedTriangle;
+	mutable GLuint m_vertexShaderTexturedTriangle = 0u;
 };
 
 }

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilderFast.cpp

@@ -98,6 +98,40 @@ public:
 	}
 };
 
+class VertexShaderTexturedRectFast : public ShaderPart
+{
+public:
+	VertexShaderTexturedRectFast(const opengl::GLInfo & _glinfo)
+	{
+		m_part =
+			"IN highp vec4 aRectPosition;						\n"
+			"IN highp vec2 aTexCoord0;							\n"
+			"IN highp vec2 aTexCoord1;							\n"
+			"IN highp vec2 aBaryCoords;							\n"
+			"													\n"
+			"OUT highp vec2 vTexCoord0;							\n"
+			"OUT highp vec2 vTexCoord1;							\n"
+			"OUT lowp vec4 vShadeColor;							\n"
+			"OUT highp vec4 vBaryCoords;						\n"
+			;
+		if (!_glinfo.isGLESX || _glinfo.noPerspective)
+			m_part += "noperspective OUT lowp vec4 vShadeColorNoperspective;\n";
+		else
+			m_part += "OUT lowp vec4 vShadeColorNoperspective;				\n";
+		m_part +=
+			"uniform lowp vec4 uRectColor;						\n"
+			"void main()										\n"
+			"{													\n"
+			"  gl_Position = aRectPosition;						\n"
+			"  vShadeColor = uRectColor;						\n"
+			"  vShadeColorNoperspective = uRectColor;			\n"
+			"  vTexCoord0 = aTexCoord0;							\n"
+			"  vTexCoord1 = aTexCoord1;							\n"
+			"  vBaryCoords = vec4(aBaryCoords, vec2(1.0) - aBaryCoords);	\n"
+			;
+	}
+};
+
 class ShaderFragmentGlobalVariablesTexFast : public ShaderPart
 {
 public:
@@ -536,6 +570,22 @@ public:
 	}
 };
 
+class ShaderFragmentCorrectTexCoords : public ShaderPart {
+public:
+	ShaderFragmentCorrectTexCoords() {
+		m_part +=
+			" highp vec2 mTexCoord0 = vTexCoord0 + vec2(0.0001);						\n"
+			" highp vec2 mTexCoord1 = vTexCoord1 + vec2(0.0001);						\n"
+			" mTexCoord0 += uTexCoordOffset[0];											\n"
+			" mTexCoord1 += uTexCoordOffset[1];											\n"
+			" if (uUseTexCoordBounds != 0) {											\n"
+			" mTexCoord0 = clamp(mTexCoord0, uTexCoordBounds0.xy, uTexCoordBounds0.zw); \n"
+			" mTexCoord1 = clamp(mTexCoord1, uTexCoordBounds1.xy, uTexCoordBounds1.zw); \n"
+			" }																			\n"
+			;
+	}
+};
+
 class ShaderFragmentReadTexCopyModeFast : public ShaderPart
 {
 public:
@@ -1090,8 +1140,9 @@ public:
 namespace glsl {
 
 CombinerProgramBuilderFast::CombinerProgramBuilderFast(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram)
-: CombinerProgramBuilderCommon(_glinfo, _useProgram, std::make_unique<CombinerProgramUniformFactoryFast>(_glinfo),
+: CombinerProgramBuilderCommon(_glinfo, _useProgram, std::make_unique<CombinerProgramUniformFactoryFast>(_glinfo))
-        std::make_unique<VertexShaderTexturedTriangleFast>(_glinfo))
+, m_vertexTexturedTriangle(new VertexShaderTexturedTriangleFast(_glinfo))
+, m_vertexTexturedRect(new VertexShaderTexturedRectFast(_glinfo))
 , m_fragmentGlobalVariablesTex(new ShaderFragmentGlobalVariablesTexFast(_glinfo))
 , m_fragmentHeaderClampWrapMirror(new ShaderFragmentHeaderClampWrapMirror(_glinfo))
 , m_fragmentHeaderReadMSTex(new ShaderFragmentHeaderReadMSTexFast(_glinfo))
@@ -1101,6 +1152,7 @@ CombinerProgramBuilderFast::CombinerProgramBuilderFast(const opengl::GLInfo & _g
 , m_fragmentReadTex1(new ShaderFragmentReadTex1Fast(_glinfo))
 , m_fragmentClampWrapMirrorTex0(new ShaderFragmentClampWrapMirrorTex0(_glinfo))
 , m_fragmentClampWrapMirrorTex1(new ShaderFragmentClampWrapMirrorTex1(_glinfo))
+, m_fragmentCorrectTexCoords(new ShaderFragmentCorrectTexCoords())
 , m_fragmentReadTexCopyMode(new ShaderFragmentReadTexCopyModeFast(_glinfo))
 , m_shaderMipmap(new ShaderMipmapFast(_glinfo))
 , m_shaderReadtex(new ShaderReadtexFast(_glinfo))
@@ -1109,6 +1161,16 @@ CombinerProgramBuilderFast::CombinerProgramBuilderFast(const opengl::GLInfo & _g
 {
 }
 
+const ShaderPart * CombinerProgramBuilderFast::getVertexShaderTexturedRect() const
+{
+	return m_vertexTexturedRect.get();
+}
+
+const ShaderPart * CombinerProgramBuilderFast::getVertexShaderTexturedTriangle() const
+{
+	return m_vertexTexturedTriangle.get();
+}
+
 void CombinerProgramBuilderFast::_writeFragmentGlobalVariablesTex(std::stringstream& ssShader) const
 {
 	 m_fragmentGlobalVariablesTex->write(ssShader);
@@ -1144,6 +1206,10 @@ void CombinerProgramBuilderFast::_writeFragmentClampWrapMirrorEngineTex1(std::st
 	m_fragmentClampWrapMirrorTex1->write(ssShader);
 }
 
+void CombinerProgramBuilderFast::_writeFragmentCorrectTexCoords(std::stringstream& ssShader)const
+{
+	m_fragmentCorrectTexCoords->write(ssShader);
+}
 void CombinerProgramBuilderFast::_writeFragmentReadTex0(std::stringstream& ssShader) const
 {
 	m_fragmentReadTex0->write(ssShader);

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilderFast.h

@@ -9,6 +9,8 @@ public:
 	CombinerProgramBuilderFast(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram);
 
 private:
+	const ShaderPart * getVertexShaderTexturedRect() const override;
+	const ShaderPart * getVertexShaderTexturedTriangle() const override;
 
 	void _writeFragmentGlobalVariablesTex(std::stringstream& ssShader) const override;
 	void _writeFragmentHeaderReadMSTex(std::stringstream& ssShader) const override;
@@ -17,6 +19,7 @@ private:
 	void _writeFragmentHeaderClampWrapMirrorEngine(std::stringstream& ssShader) const override;
 	void _writeFragmentClampWrapMirrorEngineTex0(std::stringstream& ssShader) const override;
 	void _writeFragmentClampWrapMirrorEngineTex1(std::stringstream& ssShader) const override;
+	void _writeFragmentCorrectTexCoords(std::stringstream& ssShader) const override;
 	void _writeFragmentReadTex0(std::stringstream& ssShader) const override;
 	void _writeFragmentReadTex1(std::stringstream& ssShader) const override;
 	void _writeFragmentReadTexCopyMode(std::stringstream& ssShader) const override;
@@ -25,6 +28,8 @@ private:
 	void _writeShaderReadtex(std::stringstream& ssShader) const override;
 	void _writeShaderReadtexCopyMode(std::stringstream& ssShader) const override;
 
+	ShaderPartPtr m_vertexTexturedTriangle;
+	ShaderPartPtr m_vertexTexturedRect;
 	ShaderPartPtr m_fragmentGlobalVariablesTex;
 	ShaderPartPtr m_fragmentHeaderClampWrapMirror;
 	ShaderPartPtr m_fragmentHeaderReadMSTex;
@@ -34,6 +39,7 @@ private:
 	ShaderPartPtr m_fragmentReadTex1;
 	ShaderPartPtr m_fragmentClampWrapMirrorTex0;
 	ShaderPartPtr m_fragmentClampWrapMirrorTex1;
+	ShaderPartPtr m_fragmentCorrectTexCoords;
 	ShaderPartPtr m_fragmentReadTexCopyMode;
 	ShaderPartPtr m_shaderMipmap;
 	ShaderPartPtr m_shaderReadtex;

src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramUniformFactoryAccurate.cpp

@@ -18,11 +18,9 @@ class URasterInfo : public UniformGroup {
 public:
 	URasterInfo(GLuint _program) {
 		LocateUniform(uVertexOffset);
-		LocateUniform(uTexCoordOffset[0]);
+		LocateUniform(uTexCoordOffset);
-		LocateUniform(uTexCoordOffset[1]);
 		LocateUniform(uUseTexCoordBounds);
-		LocateUniform(uTexCoordBounds0);
+		LocateUniform(uTexCoordBounds);
-		LocateUniform(uTexCoordBounds1);
 	}
 
 	void update(bool _force) override {
@@ -36,7 +34,7 @@ public:
 		/* effective. Still, an heuristic is applied to render texture rectangles as correctly as possible  */
 		/* in higher resolutions too. See issue #2324 for details. 											*/
 		const float vertexOffset = isNativeRes ? 0.5f : 0.0f;
-		float texCoordOffset[2][2] = { 0.0f, 0.0f };
+		float texCoordOffset[2] = { 0.0f, 0.0f };
 		if (isTexRect && !isNativeRes) {
 			float scale[2] = { 0.0f, 0.0f };
 			if (config.graphics2D.enableNativeResTexrects != 0 && gDP.otherMode.textureFilter != G_TF_POINT) {
@@ -45,74 +43,58 @@ public:
 				scale[0] = scale[1] = static_cast<float>(config.frameBufferEmulation.nativeResFactor);
 			}
 
-			for (int t = 0; t < 2; t++) {
+			if (config.frameBufferEmulation.nativeResFactor != 0) {
-				const CachedTexture* _pTexture = textureCache().current[t];
+				if (gDP.otherMode.textureFilter != G_TF_POINT && gDP.otherMode.cycleType != G_CYC_COPY) {
-				if (_pTexture != nullptr) {
+					texCoordOffset[0] = -0.5f * gDP.lastTexRectInfo.dsdx;
-					if (config.frameBufferEmulation.nativeResFactor != 0) {
+					texCoordOffset[1] = -0.5f * gDP.lastTexRectInfo.dtdy;
-						if (gDP.otherMode.textureFilter != G_TF_POINT && gDP.otherMode.cycleType != G_CYC_COPY) {
+				} else {
-							texCoordOffset[t][0] = -0.5f * gDP.lastTexRectInfo.dsdx;
+					texCoordOffset[0] = (gDP.lastTexRectInfo.dsdx >= 0.0f ? -0.5f / scale[0] : -1.0f + 0.5f / scale[0]) * gDP.lastTexRectInfo.dsdx;
-							texCoordOffset[t][1] = -0.5f * gDP.lastTexRectInfo.dtdy;
+					texCoordOffset[1] = (gDP.lastTexRectInfo.dtdy >= 0.0f ? -0.5f / scale[1] : -1.0f + 0.5f / scale[1]) * gDP.lastTexRectInfo.dtdy;
-						} else {
+				}
-							texCoordOffset[t][0] = (gDP.lastTexRectInfo.dsdx >= 0.0f ? -0.5f / scale[0] : -1.0f + 0.5f / scale[0]) * gDP.lastTexRectInfo.dsdx;
+			} else {
-							texCoordOffset[t][1] = (gDP.lastTexRectInfo.dtdy >= 0.0f ? -0.5f / scale[1] : -1.0f + 0.5f / scale[1]) * gDP.lastTexRectInfo.dtdy;
+				texCoordOffset[0] = (gDP.lastTexRectInfo.dsdx >= 0.0f ? 0.0f : -1.0f) * gDP.lastTexRectInfo.dsdx;
-						}
+				texCoordOffset[1] = (gDP.lastTexRectInfo.dtdy >= 0.0f ? 0.0f : -1.0f) * gDP.lastTexRectInfo.dtdy;
-					} else {
+				if (gDP.otherMode.textureFilter != G_TF_POINT && gDP.otherMode.cycleType != G_CYC_COPY) {
-						texCoordOffset[t][0] = (gDP.lastTexRectInfo.dsdx >= 0.0f ? 0.0f : -1.0f) * gDP.lastTexRectInfo.dsdx;
+					texCoordOffset[0] -= 0.5f;
-						texCoordOffset[t][1] = (gDP.lastTexRectInfo.dtdy >= 0.0f ? 0.0f : -1.0f) * gDP.lastTexRectInfo.dtdy;
+					texCoordOffset[1] -= 0.5f;
-						if (gDP.otherMode.textureFilter != G_TF_POINT && gDP.otherMode.cycleType != G_CYC_COPY) {
-							texCoordOffset[t][0] -= 0.5f;
-							texCoordOffset[t][1] -= 0.5f;
-						}
-					}
 				}
 			}
 		}
 		/* Hack for framebuffer textures. See #519 and #2112 */
 		if ((config.generalEmulation.hacks & hack_fbTextureOffset) != 0) {
-			for (int t = 0; t < 2; t++) {
+			const CachedTexture* _pTexture = textureCache().current[0];
-				const CachedTexture* _pTexture = textureCache().current[t];
+			if (_pTexture != nullptr) {
-				if (_pTexture != nullptr) {
+				if (gDP.otherMode.textureFilter != G_TF_POINT && _pTexture->frameBufferTexture != CachedTexture::fbNone) {
-					if (gDP.otherMode.textureFilter != G_TF_POINT && _pTexture->frameBufferTexture != CachedTexture::fbNone) {
+					texCoordOffset[0] -= 1.0f;
-						texCoordOffset[t][0] -= 1.0f;
+					texCoordOffset[1] -= 1.0f;
-						texCoordOffset[t][1] -= 1.0f;
-					}
 				}
 			}
 		}
-		float tcbounds[2][4] = {};
+		float tcbounds[4] = {};
 		if (useTexCoordBounds) {
-			f32 uls, lrs, ult, lrt, S, T;
+			f32 S = _FIXED2FLOAT(gDP.lastTexRectInfo.s, 5);
-			for (int t = 0; t < 2; t++) {
+			f32 T = _FIXED2FLOAT(gDP.lastTexRectInfo.t, 5);
-				const CachedTexture * _pTexture = textureCache().current[t];
+			f32 uls = S + (ceilf(gDP.lastTexRectInfo.ulx) - gDP.lastTexRectInfo.ulx) * gDP.lastTexRectInfo.dsdx;
-				if (_pTexture != nullptr) {
+			f32 lrs = S + (ceilf(gDP.lastTexRectInfo.lrx) - gDP.lastTexRectInfo.ulx - 1.0f) * gDP.lastTexRectInfo.dsdx;
-					S = _FIXED2FLOAT(gDP.lastTexRectInfo.s, 5);
+			f32 ult = T + (ceilf(gDP.lastTexRectInfo.uly) - gDP.lastTexRectInfo.uly) * gDP.lastTexRectInfo.dtdy;
-					T = _FIXED2FLOAT(gDP.lastTexRectInfo.t, 5);
+			f32 lrt = T + (ceilf(gDP.lastTexRectInfo.lry) - gDP.lastTexRectInfo.uly - 1.0f) * gDP.lastTexRectInfo.dtdy;
-					uls = S + (ceilf(gDP.lastTexRectInfo.ulx) - gDP.lastTexRectInfo.ulx) * gDP.lastTexRectInfo.dsdx;
+			tcbounds[0] = fmin(uls, lrs);
-					lrs = S + (ceilf(gDP.lastTexRectInfo.lrx) - gDP.lastTexRectInfo.ulx - 1.0f) * gDP.lastTexRectInfo.dsdx;
+			tcbounds[1] = fmin(ult, lrt);
-					ult = T + (ceilf(gDP.lastTexRectInfo.uly) - gDP.lastTexRectInfo.uly) * gDP.lastTexRectInfo.dtdy;
+			tcbounds[2] = fmax(uls, lrs);
-					lrt = T + (ceilf(gDP.lastTexRectInfo.lry) - gDP.lastTexRectInfo.uly - 1.0f) * gDP.lastTexRectInfo.dtdy;
+			tcbounds[3] = fmax(ult, lrt);
-					tcbounds[t][0] = fmin(uls, lrs);
-					tcbounds[t][1] = fmin(ult, lrt);
-					tcbounds[t][2] = fmax(uls, lrs);
-					tcbounds[t][3] = fmax(ult, lrt);
-				}
-			}
 		}
 
 		uVertexOffset.set(vertexOffset, vertexOffset, _force);
-		uTexCoordOffset[0].set(texCoordOffset[0][0], texCoordOffset[0][1], _force);
+		uTexCoordOffset.set(texCoordOffset[0], texCoordOffset[1], _force);
-		uTexCoordOffset[1].set(texCoordOffset[1][0], texCoordOffset[1][1], _force);
 		uUseTexCoordBounds.set(useTexCoordBounds ? 1 : 0, _force);
-		uTexCoordBounds0.set(tcbounds[0], _force);
+		uTexCoordBounds.set(tcbounds, _force);
-		uTexCoordBounds1.set(tcbounds[1], _force);
 	}
 
 private:
 	fv2Uniform uVertexOffset;
-	fv2Uniform uTexCoordOffset[2];
+	fv2Uniform uTexCoordOffset;
 	iUniform uUseTexCoordBounds;
-	fv4Uniform uTexCoordBounds0;
+	fv4Uniform uTexCoordBounds;
-	fv4Uniform uTexCoordBounds1;
 };
 
 class UMipmap : public UniformGroup

src/Graphics/OpenGLContext/GLSL/glsl_ShaderStorage.h

@@ -20,7 +20,7 @@ namespace glsl {
 		bool _saveCombinerKeys(const graphics::Combiners & _combiners) const;
 		bool _loadFromCombinerKeys(graphics::Combiners & _combiners);
 
-		const u32 m_formatVersion = 0x39U;
+		const u32 m_formatVersion = 0x3AU;
 		const u32 m_keysFormatVersion = 0x05;
 		const opengl::GLInfo & m_glinfo;
 		opengl::CachedUseProgram * m_useProgram;