ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GS: Split convert and present shaders

This commit is contained in:
Connor McLaughlin 2022-06-04 14:58:05 +10:00 committed by refractionpcsx2
parent d0e3b8c4ee
commit a9819542d4
24 changed files with 991 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
bin/resources/shaders/dx11/convert.fx
View File

@ -91,30 +91,6 @@ PS_OUTPUT ps_filter_transparency(PS_INPUT input)
return output;
}
float4 ps_crt(PS_INPUT input, int i)
{
float4 mask[4] =
{
float4(1, 0, 0, 0),
float4(0, 1, 0, 0),
float4(0, 0, 1, 0),
float4(1, 1, 1, 0)
};
return sample_c(input.t) * saturate(mask[i] + 0.5f);
}
float4 ps_scanlines(PS_INPUT input, int i)
{
float4 mask[2] =
{
float4(1, 1, 1, 0),
float4(0, 0, 0, 0)
};
return sample_c(input.t) * saturate(mask[i] + 0.5f);
}
// Need to be careful with precision here, it can break games like Spider-Man 3 and Dogs Life
uint ps_convert_rgba8_16bits(PS_INPUT input) : SV_Target0
{
@ -159,55 +135,6 @@ PS_OUTPUT ps_mod256(PS_INPUT input)
return output;
}
PS_OUTPUT ps_filter_scanlines(PS_INPUT input)
{
PS_OUTPUT output;
uint4 p = (uint4)input.p;
output.c = ps_scanlines(input, p.y % 2);
return output;
}
PS_OUTPUT ps_filter_diagonal(PS_INPUT input)
{
PS_OUTPUT output;
uint4 p = (uint4)input.p;
output.c = ps_crt(input, (p.x + (p.y % 3)) % 3);
return output;
}
PS_OUTPUT ps_filter_triangular(PS_INPUT input)
{
PS_OUTPUT output;
uint4 p = (uint4)input.p;
// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3);
output.c = ps_crt(input, ((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3);
return output;
}
static const float PI = 3.14159265359f;
PS_OUTPUT ps_filter_complex(PS_INPUT input) // triangular
{
PS_OUTPUT output;
float2 texdim, halfpixel;
Texture.GetDimensions(texdim.x, texdim.y);
if (ddy(input.t.y) * input.t.y > 0.5)
output.c = sample_c(input.t);
else
output.c = (0.9 - 0.4 * cos(2 * PI * input.t.y * texdim.y)) * sample_c(float2(input.t.x, (floor(input.t.y * texdim.y) + 0.5) / texdim.y));
return output;
}
uint ps_convert_float32_32bits(PS_INPUT input) : SV_Target0
{
// Convert a FLOAT32 depth texture into a 32 bits UINT texture

148
bin/resources/shaders/dx11/present.fx Normal file
View File

@ -0,0 +1,148 @@
#ifdef SHADER_MODEL // make safe to include in resource file to enforce dependency
#ifndef PS_SCALE_FACTOR
#define PS_SCALE_FACTOR 1
#endif
struct VS_INPUT
{
float4 p : POSITION;
float2 t : TEXCOORD0;
float4 c : COLOR;
};
struct VS_OUTPUT
{
float4 p : SV_Position;
float2 t : TEXCOORD0;
float4 c : COLOR;
};
cbuffer cb0 : register(b0)
{
float4 u_source_rect;
float4 u_target_rect;
float2 u_source_size;
float2 u_target_size;
float2 u_target_resolution;
float2 u_rcp_target_resolution; // 1 / u_target_resolution
float2 u_source_resolution;
float2 u_rcp_source_resolution; // 1 / u_source_resolution
float u_time;
float3 cb0_pad0;
};
Texture2D Texture;
SamplerState TextureSampler;
float4 sample_c(float2 uv)
{
return Texture.Sample(TextureSampler, uv);
}
struct PS_INPUT
{
float4 p : SV_Position;
float2 t : TEXCOORD0;
float4 c : COLOR;
};
struct PS_OUTPUT
{
float4 c : SV_Target0;
};
VS_OUTPUT vs_main(VS_INPUT input)
{
VS_OUTPUT output;
output.p = input.p;
output.t = input.t;
output.c = input.c;
return output;
}
PS_OUTPUT ps_copy(PS_INPUT input)
{
PS_OUTPUT output;
output.c = sample_c(input.t);
return output;
}
float4 ps_crt(PS_INPUT input, int i)
{
float4 mask[4] =
{
float4(1, 0, 0, 0),
float4(0, 1, 0, 0),
float4(0, 0, 1, 0),
float4(1, 1, 1, 0)
};
return sample_c(input.t) * saturate(mask[i] + 0.5f);
}
float4 ps_scanlines(PS_INPUT input, int i)
{
float4 mask[2] =
{
float4(1, 1, 1, 0),
float4(0, 0, 0, 0)
};
return sample_c(input.t) * saturate(mask[i] + 0.5f);
}
PS_OUTPUT ps_filter_scanlines(PS_INPUT input)
{
PS_OUTPUT output;
uint4 p = (uint4)input.p;
output.c = ps_scanlines(input, p.y % 2);
return output;
}
PS_OUTPUT ps_filter_diagonal(PS_INPUT input)
{
PS_OUTPUT output;
uint4 p = (uint4)input.p;
output.c = ps_crt(input, (p.x + (p.y % 3)) % 3);
return output;
}
PS_OUTPUT ps_filter_triangular(PS_INPUT input)
{
PS_OUTPUT output;
uint4 p = (uint4)input.p;
// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3);
output.c = ps_crt(input, ((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3);
return output;
}
static const float PI = 3.14159265359f;
PS_OUTPUT ps_filter_complex(PS_INPUT input) // triangular
{
PS_OUTPUT output;
float2 texdim, halfpixel;
Texture.GetDimensions(texdim.x, texdim.y);
if (ddy(input.t.y) * input.t.y > 0.5)
output.c = sample_c(input.t);
else
output.c = (0.9 - 0.4 * cos(2 * PI * input.t.y * texdim.y)) * sample_c(float2(input.t.x, (floor(input.t.y * texdim.y) + 0.5) / texdim.y));
return output;
}
#endif

76
bin/resources/shaders/opengl/convert.glsl
View File

@ -47,18 +47,6 @@ vec4 sample_c()
return texture(TextureSampler, PSin_t);
}
vec4 ps_crt(uint i)
{
vec4 mask[4] = vec4[4]
(
vec4(1, 0, 0, 0),
vec4(0, 1, 0, 0),
vec4(0, 0, 1, 0),
vec4(1, 1, 1, 0)
);
return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
#ifdef ps_copy
void ps_copy()
{
@ -242,70 +230,6 @@ void ps_filter_transparency()
}
#endif
#ifdef ps_filter_scanlines
vec4 ps_scanlines(uint i)
{
vec4 mask[2] =
{
vec4(1, 1, 1, 0),
vec4(0, 0, 0, 0)
};
return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
void ps_filter_scanlines() // scanlines
{
highp uvec4 p = uvec4(gl_FragCoord);
vec4 c = ps_scanlines(p.y % 2u);
SV_Target0 = c;
}
#endif
#ifdef ps_filter_diagonal
void ps_filter_diagonal() // diagonal
{
highp uvec4 p = uvec4(gl_FragCoord);
vec4 c = ps_crt((p.x + (p.y % 3u)) % 3u);
SV_Target0 = c;
}
#endif
#ifdef ps_filter_triangular
void ps_filter_triangular() // triangular
{
highp uvec4 p = uvec4(gl_FragCoord);
vec4 c = ps_crt(((p.x + ((p.y >> 1u) & 1u) * 3u) >> 1u) % 3u);
SV_Target0 = c;
}
#endif
#ifdef ps_filter_complex
void ps_filter_complex()
{
const float PI = 3.14159265359f;
vec2 texdim = vec2(textureSize(TextureSampler, 0));
vec4 c;
if (dFdy(PSin_t.y) * PSin_t.y > 0.5f) {
c = sample_c();
} else {
float factor = (0.9f - 0.4f * cos(2.0f * PI * PSin_t.y * texdim.y));
c = factor * texture(TextureSampler, vec2(PSin_t.x, (floor(PSin_t.y * texdim.y) + 0.5f) / texdim.y));
}
SV_Target0 = c;
}
#endif
// Used for DATE (stencil)
// DATM == 1
#ifdef ps_datm1

139
bin/resources/shaders/opengl/present.glsl Normal file
View File

@ -0,0 +1,139 @@
//#version 420 // Keep it for editor detection
#ifdef VERTEX_SHADER
layout(location = 0) in vec2 POSITION;
layout(location = 1) in vec2 TEXCOORD0;
layout(location = 7) in vec4 COLOR;
// FIXME set the interpolation (don't know what dx do)
// flat means that there is no interpolation. The value given to the fragment shader is based on the provoking vertex conventions.
//
// noperspective means that there will be linear interpolation in window-space. This is usually not what you want, but it can have its uses.
//
// smooth, the default, means to do perspective-correct interpolation.
//
// The centroid qualifier only matters when multisampling. If this qualifier is not present, then the value is interpolated to the pixel's center, anywhere in the pixel, or to one of the pixel's samples. This sample may lie outside of the actual primitive being rendered, since a primitive can cover only part of a pixel's area. The centroid qualifier is used to prevent this; the interpolation point must fall within both the pixel's area and the primitive's area.
out vec4 PSin_p;
out vec2 PSin_t;
out vec4 PSin_c;
void vs_main()
{
PSin_p = vec4(POSITION, 0.5f, 1.0f);
PSin_t = TEXCOORD0;
PSin_c = COLOR;
gl_Position = vec4(POSITION, 0.5f, 1.0f); // NOTE I don't know if it is possible to merge POSITION_OUT and gl_Position
}
#endif
#ifdef FRAGMENT_SHADER
uniform vec4 u_source_rect;
uniform vec4 u_target_rect;
uniform vec2 u_source_size;
uniform vec2 u_target_size;
uniform vec2 u_target_resolution;
uniform vec2 u_rcp_target_resolution; // 1 / u_target_resolution
uniform vec2 u_source_resolution;
uniform vec2 u_rcp_source_resolution; // 1 / u_source_resolution
uniform float u_time;
uniform vec3 cb0_pad0;
in vec4 PSin_p;
in vec2 PSin_t;
in vec4 PSin_c;
layout(location = 0) out vec4 SV_Target0;
vec4 sample_c()
{
return texture(TextureSampler, PSin_t);
}
vec4 ps_crt(uint i)
{
vec4 mask[4] = vec4[4]
(
vec4(1, 0, 0, 0),
vec4(0, 1, 0, 0),
vec4(0, 0, 1, 0),
vec4(1, 1, 1, 0)
);
return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
#ifdef ps_copy
void ps_copy()
{
SV_Target0 = sample_c();
}
#endif
#ifdef ps_filter_scanlines
vec4 ps_scanlines(uint i)
{
vec4 mask[2] =
{
vec4(1, 1, 1, 0),
vec4(0, 0, 0, 0)
};
return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
void ps_filter_scanlines() // scanlines
{
highp uvec4 p = uvec4(gl_FragCoord);
vec4 c = ps_scanlines(p.y % 2u);
SV_Target0 = c;
}
#endif
#ifdef ps_filter_diagonal
void ps_filter_diagonal() // diagonal
{
highp uvec4 p = uvec4(gl_FragCoord);
vec4 c = ps_crt((p.x + (p.y % 3u)) % 3u);
SV_Target0 = c;
}
#endif
#ifdef ps_filter_triangular
void ps_filter_triangular() // triangular
{
highp uvec4 p = uvec4(gl_FragCoord);
vec4 c = ps_crt(((p.x + ((p.y >> 1u) & 1u) * 3u) >> 1u) % 3u);
SV_Target0 = c;
}
#endif
#ifdef ps_filter_complex
void ps_filter_complex()
{
const float PI = 3.14159265359f;
vec2 texdim = vec2(textureSize(TextureSampler, 0));
vec4 c;
if (dFdy(PSin_t.y) * PSin_t.y > 0.5f) {
c = sample_c();
} else {
float factor = (0.9f - 0.4f * cos(2.0f * PI * PSin_t.y * texdim.y));
c = factor * texture(TextureSampler, vec2(PSin_t.x, (floor(PSin_t.y * texdim.y) + 0.5f) / texdim.y));
}
SV_Target0 = c;
}
#endif
#endif

62
bin/resources/shaders/vulkan/convert.glsl
View File

@ -34,29 +34,6 @@ vec4 sample_c(vec2 uv)
return texture(samp0, uv);
}
vec4 ps_crt(uint i)
{
vec4 mask[4] = vec4[4]
(
vec4(1, 0, 0, 0),
vec4(0, 1, 0, 0),
vec4(0, 0, 1, 0),
vec4(1, 1, 1, 0)
);
return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
vec4 ps_scanlines(uint i)
{
vec4 mask[2] =
{
vec4(1, 1, 1, 0),
vec4(0, 0, 0, 0)
};
return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
#ifdef ps_copy
void ps_copy()
{
@ -125,45 +102,6 @@ void ps_mod256()
}
#endif
#ifdef ps_filter_scanlines
void ps_filter_scanlines() // scanlines
{
uvec4 p = uvec4(gl_FragCoord);
o_col0 = ps_scanlines(p.y % 2);
}
#endif
#ifdef ps_filter_diagonal
void ps_filter_diagonal() // diagonal
{
uvec4 p = uvec4(gl_FragCoord);
o_col0 = ps_crt((p.x + (p.y % 3)) % 3);
}
#endif
#ifdef ps_filter_triangular
void ps_filter_triangular() // triangular
{
uvec4 p = uvec4(gl_FragCoord);
// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3);
o_col0 = ps_crt(((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3);
}
#endif
#ifdef ps_filter_complex
void ps_filter_complex() // triangular
{
const float PI = 3.14159265359f;
vec2 texdim = vec2(textureSize(samp0, 0));
if (dFdy(v_tex.y) * v_tex.y > 0.5)
o_col0 = sample_c(v_tex);
else
o_col0 = (0.9 - 0.4 * cos(2 * PI * v_tex.y * texdim.y)) * sample_c(vec2(v_tex.x, (floor(v_tex.y * texdim.y) + 0.5) / texdim.y));
}
#endif
#ifdef ps_convert_float32_32bits
void ps_convert_float32_32bits()
{

116
bin/resources/shaders/vulkan/present.glsl Normal file
View File

@ -0,0 +1,116 @@
#ifndef PS_SCALE_FACTOR
#define PS_SCALE_FACTOR 1
#endif
#ifdef VERTEX_SHADER
layout(location = 0) in vec4 a_pos;
layout(location = 1) in vec2 a_tex;
layout(location = 0) out vec2 v_tex;
void main()
{
gl_Position = vec4(a_pos.x, -a_pos.y, a_pos.z, a_pos.w);
v_tex = a_tex;
}
#endif
#ifdef FRAGMENT_SHADER
layout(push_constant) uniform cb10
{
vec4 u_source_rect;
vec4 u_target_rect;
vec2 u_source_size;
vec2 u_target_size;
vec2 u_target_resolution;
vec2 u_rcp_target_resolution; // 1 / u_target_resolution
vec2 u_source_resolution;
vec2 u_rcp_source_resolution; // 1 / u_source_resolution
float u_time;
vec3 cb0_pad0;
};
layout(location = 0) in vec2 v_tex;
layout(location = 0) out vec4 o_col0;
layout(set = 0, binding = 0) uniform sampler2D samp0;
vec4 sample_c(vec2 uv)
{
return texture(samp0, uv);
}
vec4 ps_crt(uint i)
{
vec4 mask[4] = vec4[4]
(
vec4(1, 0, 0, 0),
vec4(0, 1, 0, 0),
vec4(0, 0, 1, 0),
vec4(1, 1, 1, 0)
);
return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
vec4 ps_scanlines(uint i)
{
vec4 mask[2] =
{
vec4(1, 1, 1, 0),
vec4(0, 0, 0, 0)
};
return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
}
#ifdef ps_copy
void ps_copy()
{
o_col0 = sample_c(v_tex);
}
#endif
#ifdef ps_filter_scanlines
void ps_filter_scanlines() // scanlines
{
uvec4 p = uvec4(gl_FragCoord);
o_col0 = ps_scanlines(p.y % 2);
}
#endif
#ifdef ps_filter_diagonal
void ps_filter_diagonal() // diagonal
{
uvec4 p = uvec4(gl_FragCoord);
o_col0 = ps_crt((p.x + (p.y % 3)) % 3);
}
#endif
#ifdef ps_filter_triangular
void ps_filter_triangular() // triangular
{
uvec4 p = uvec4(gl_FragCoord);
// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3);
o_col0 = ps_crt(((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3);
}
#endif
#ifdef ps_filter_complex
void ps_filter_complex() // triangular
{
const float PI = 3.14159265359f;
vec2 texdim = vec2(textureSize(samp0, 0));
if (dFdy(v_tex.y) * v_tex.y > 0.5)
o_col0 = sample_c(v_tex);
else
o_col0 = (0.9 - 0.4 * cos(2 * PI * v_tex.y * texdim.y)) * sample_c(vec2(v_tex.x, (floor(v_tex.y * texdim.y) + 0.5) / texdim.y));
}
#endif
#endif

1
pcsx2/CMakeLists.txt
View File

@ -798,6 +798,7 @@ endif()
set(pcsx2GSMetalShaders
GS/Renderers/Metal/convert.metal
GS/Renderers/Metal/present.metal
GS/Renderers/Metal/merge.metal
GS/Renderers/Metal/interlace.metal
GS/Renderers/Metal/tfx.metal

36
pcsx2/GS/Renderers/Common/GSDevice.cpp
View File

@ -22,16 +22,13 @@ const char* shaderName(ShaderConvert value)
{
switch (value)
{
// clang-format off
case ShaderConvert::COPY: return "ps_copy";
case ShaderConvert::RGBA8_TO_16_BITS: return "ps_convert_rgba8_16bits";
case ShaderConvert::DATM_1: return "ps_datm1";
case ShaderConvert::DATM_0: return "ps_datm0";
case ShaderConvert::MOD_256: return "ps_mod256";
case ShaderConvert::SCANLINE: return "ps_filter_scanlines";
case ShaderConvert::DIAGONAL_FILTER: return "ps_filter_diagonal";
case ShaderConvert::TRANSPARENCY_FILTER: return "ps_filter_transparency";
case ShaderConvert::TRIANGULAR_FILTER: return "ps_filter_triangular";
case ShaderConvert::COMPLEX_FILTER: return "ps_filter_complex";
case ShaderConvert::FLOAT32_TO_16_BITS: return "ps_convert_float32_32bits";
case ShaderConvert::FLOAT32_TO_32_BITS: return "ps_convert_float32_32bits";
case ShaderConvert::FLOAT32_TO_RGBA8: return "ps_convert_float32_rgba8";
@ -43,12 +40,30 @@ const char* shaderName(ShaderConvert value)
case ShaderConvert::DEPTH_COPY: return "ps_depth_copy";
case ShaderConvert::RGBA_TO_8I: return "ps_convert_rgba_8i";
case ShaderConvert::YUV: return "ps_yuv";
// clang-format on
default:
ASSERT(0);
return "ShaderConvertUnknownShader";
}
}
const char* shaderName(PresentShader value)
{
switch (value)
{
// clang-format off
case PresentShader::COPY: return "ps_copy";
case PresentShader::SCANLINE: return "ps_filter_scanlines";
case PresentShader::DIAGONAL_FILTER: return "ps_filter_diagonal";
case PresentShader::TRIANGULAR_FILTER: return "ps_filter_triangular";
case PresentShader::COMPLEX_FILTER: return "ps_filter_complex";
// clang-format on
default:
ASSERT(0);
return "DisplayShaderUnknownShader";
}
}
static int MipmapLevelsForSize(int width, int height)
{
return std::min(static_cast<int>(std::log2(std::max(width, height))) + 1, MAXIMUM_TEXTURE_MIPMAP_LEVELS);
@ -56,18 +71,7 @@ static int MipmapLevelsForSize(int width, int height)
std::unique_ptr<GSDevice> g_gs_device;
GSDevice::GSDevice()
: m_merge(NULL)
, m_weavebob(NULL)
, m_blend(NULL)
, m_target_tmp(NULL)
, m_current(NULL)
, m_frame(0)
, m_rbswapped(false)
{
memset(&m_vertex, 0, sizeof(m_vertex));
memset(&m_index, 0, sizeof(m_index));
}
GSDevice::GSDevice() = default;
GSDevice::~GSDevice()
{

74
pcsx2/GS/Renderers/Common/GSDevice.h
View File

@ -36,11 +36,7 @@ enum class ShaderConvert
DATM_1,
DATM_0,
MOD_256,
SCANLINE,
DIAGONAL_FILTER,
TRANSPARENCY_FILTER,
TRIANGULAR_FILTER,
COMPLEX_FILTER,
FLOAT32_TO_16_BITS,
FLOAT32_TO_32_BITS,
FLOAT32_TO_RGBA8,
@ -55,9 +51,20 @@ enum class ShaderConvert
Count
};
enum class PresentShader
{
COPY = 0,
SCANLINE,
DIAGONAL_FILTER,
TRIANGULAR_FILTER,
COMPLEX_FILTER,
Count
};
/// Get the name of a shader
/// (Can't put methods on an enum class)
const char* shaderName(ShaderConvert value);
const char* shaderName(PresentShader value);
enum ChannelFetch
{
@ -72,6 +79,41 @@ enum ChannelFetch
#pragma pack(push, 1)
class DisplayConstantBuffer
{
public:
GSVector4 SourceRect; // +0,xyzw
GSVector4 TargetRect; // +16,xyzw
GSVector2 SourceSize; // +32,xy
GSVector2 TargetSize; // +40,zw
GSVector2 TargetResolution; // +48,xy
GSVector2 RcpTargetResolution; // +56,zw
GSVector2 SourceResolution; // +64,xy
GSVector2 RcpSourceResolution; // +72,zw
GSVector4 TimeAndPad; // seconds since GS init +76,xyzw
// +96
// assumes that sRect is normalized
void SetSource(const GSVector4& sRect, const GSVector2i& sSize)
{
SourceRect = sRect;
SourceResolution = GSVector2(static_cast<float>(sSize.x), static_cast<float>(sSize.y));
RcpSourceResolution = GSVector2(1.0f) / SourceResolution;
SourceSize = GSVector2((sRect.z - sRect.x) * SourceResolution.x, (sRect.w - sRect.y) * SourceResolution.y);
}
void SetTarget(const GSVector4& dRect, const GSVector2i& dSize)
{
TargetRect = dRect;
TargetResolution = GSVector2(static_cast<float>(dSize.x), static_cast<float>(dSize.y));
RcpTargetResolution = GSVector2(1.0f) / TargetResolution;
TargetSize = GSVector2(dRect.z - dRect.x, dRect.w - dRect.y);
}
void SetTime(float time)
{
TimeAndPad = GSVector4(time);
}
};
class MergeConstantBuffer
{
public:
@ -623,22 +665,23 @@ private:
protected:
static constexpr u32 MAX_POOLED_TEXTURES = 300;
HostDisplay* m_display;
GSTexture* m_merge;
GSTexture* m_weavebob;
GSTexture* m_blend;
GSTexture* m_target_tmp;
GSTexture* m_current;
HostDisplay* m_display = nullptr;
GSTexture* m_merge = nullptr;
GSTexture* m_weavebob = nullptr;
GSTexture* m_blend = nullptr;
GSTexture* m_target_tmp = nullptr;
GSTexture* m_current = nullptr;
struct
{
size_t stride, start, count, limit;
} m_vertex;
} m_vertex = {};
struct
{
size_t start, count, limit;
} m_index;
unsigned int m_frame; // for ageing the pool
bool m_rbswapped;
} m_index = {};
unsigned int m_frame = 0; // for ageing the pool
bool m_rbswapped = false;
FeatureSupport m_features;
virtual GSTexture* CreateSurface(GSTexture::Type type, int width, int height, int levels, GSTexture::Format format) = 0;
@ -722,6 +765,9 @@ public:
void StretchRect(GSTexture* sTex, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true);
/// Performs a screen blit for display. If dTex is null, it assumes you are writing to the system framebuffer/swap chain.
virtual void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) {}
virtual void RenderHW(GSHWDrawConfig& config) {}
__fi FeatureSupport Features() const { return m_features; }

29
pcsx2/GS/Renderers/Common/GSRenderer.cpp
View File

@ -23,7 +23,9 @@
#include "common/FileSystem.h"
#include "common/Path.h"
#include "common/StringUtil.h"
#include "common/Timer.h"
#include "fmt/core.h"
#include <array>
#ifndef PCSX2_CORE
#include "gui/AppCoreThread.h"
@ -54,9 +56,17 @@ static std::string GetDumpSerial()
}
#endif
static constexpr std::array<PresentShader, 5> s_tv_shader_indices = {
PresentShader::COPY, PresentShader::SCANLINE,
PresentShader::DIAGONAL_FILTER, PresentShader::TRIANGULAR_FILTER,
PresentShader::COMPLEX_FILTER};
std::unique_ptr<GSRenderer> g_gs_renderer;
GSRenderer::GSRenderer() = default;
GSRenderer::GSRenderer()
: m_shader_time_start(Common::Timer::GetCurrentValue())
{
}
GSRenderer::~GSRenderer() = default;
@ -559,11 +569,11 @@ void GSRenderer::VSync(u32 field, bool registers_written)
const GSVector4 draw_rect(CalculateDrawRect(display->GetWindowWidth(), display->GetWindowHeight(),
current->GetWidth(), current->GetHeight(), display->GetDisplayAlignment(), display->UsesLowerLeftOrigin(), GetVideoMode() == GSVideoMode::SDTV_480P));
static constexpr ShaderConvert s_shader[5] = {ShaderConvert::COPY, ShaderConvert::SCANLINE,
ShaderConvert::DIAGONAL_FILTER, ShaderConvert::TRIANGULAR_FILTER,
ShaderConvert::COMPLEX_FILTER}; // FIXME
const u64 current_time = Common::Timer::GetCurrentValue();
const float shader_time = static_cast<float>(Common::Timer::ConvertValueToSeconds(current_time - m_shader_time_start));
g_gs_device->StretchRect(current, nullptr, draw_rect, s_shader[GSConfig.TVShader], GSConfig.LinearPresent);
g_gs_device->PresentRect(current, GSVector4(0, 0, 1, 1), nullptr, draw_rect,
s_tv_shader_indices[GSConfig.TVShader], shader_time, GSConfig.LinearPresent);
}
Host::EndPresentFrame();
@ -757,12 +767,11 @@ void GSRenderer::PresentCurrentFrame()
HostDisplay* const display = g_gs_device->GetDisplay();
const GSVector4 draw_rect(CalculateDrawRect(display->GetWindowWidth(), display->GetWindowHeight(),
current->GetWidth(), current->GetHeight(), display->GetDisplayAlignment(), display->UsesLowerLeftOrigin(), GetVideoMode() == GSVideoMode::SDTV_480P));
const u64 current_time = Common::Timer::GetCurrentValue();
const float shader_time = static_cast<float>(Common::Timer::ConvertValueToSeconds(current_time - m_shader_time_start));
static constexpr ShaderConvert s_shader[5] = { ShaderConvert::COPY, ShaderConvert::SCANLINE,
ShaderConvert::DIAGONAL_FILTER, ShaderConvert::TRIANGULAR_FILTER,
ShaderConvert::COMPLEX_FILTER }; // FIXME
g_gs_device->StretchRect(current, nullptr, draw_rect, s_shader[GSConfig.TVShader], GSConfig.LinearPresent);
g_gs_device->PresentRect(current, GSVector4(0, 0, 1, 1), nullptr, draw_rect,
s_tv_shader_indices[GSConfig.TVShader], shader_time, GSConfig.LinearPresent);
}
Host::EndPresentFrame();

2
pcsx2/GS/Renderers/Common/GSRenderer.h
View File

@ -30,6 +30,8 @@ class GSRenderer : public GSState
private:
bool Merge(int field);
u64 m_shader_time_start = 0;
#ifndef PCSX2_CORE
GSCapture m_capture;
std::mutex m_snapshot_mutex;

101
pcsx2/GS/Renderers/DX11/GSDevice11.cpp
View File

@ -153,6 +153,30 @@ bool GSDevice11::Create(HostDisplay* display)
return false;
}
shader = Host::ReadResourceFileToString("shaders/dx11/present.fx");
if (!shader.has_value())
return false;
if (!m_shader_cache.GetVertexShaderAndInputLayout(m_dev.get(), m_present.vs.put(), m_present.il.put(),
il_convert, std::size(il_convert), *shader, sm_model.GetPtr(), "vs_main"))
{
return false;
}
for (size_t i = 0; i < std::size(m_present.ps); i++)
{
m_present.ps[i] = m_shader_cache.GetPixelShader(m_dev.get(), *shader, sm_model.GetPtr(), shaderName(static_cast<PresentShader>(i)));
if (!m_present.ps[i])
return false;
}
memset(&bd, 0, sizeof(bd));
bd.ByteWidth = sizeof(DisplayConstantBuffer);
bd.Usage = D3D11_USAGE_DEFAULT;
bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
m_dev->CreateBuffer(&bd, nullptr, m_present.ps_cb.put());
memset(&dsd, 0, sizeof(dsd));
m_dev->CreateDepthStencilState(&dsd, m_convert.dss.put());
@ -665,6 +689,83 @@ void GSDevice11::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
PSSetShaderResources(nullptr, nullptr);
}
void GSDevice11::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear)
{
ASSERT(sTex);
BeginScene();
GSVector2i ds;
if (dTex)
{
ds = dTex->GetSize();
OMSetRenderTargets(dTex, nullptr);
}
else
{
ds = GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight());
}
DisplayConstantBuffer cb;
cb.SetSource(sRect, sTex->GetSize());
cb.SetTarget(dRect, ds);
cb.SetTime(shaderTime);
m_ctx->UpdateSubresource(m_present.ps_cb.get(), 0, nullptr, &cb, 0, 0);
// om
OMSetDepthStencilState(m_convert.dss.get(), 0);
OMSetBlendState(m_convert.bs.get(), 0);
// ia
const float left = dRect.x * 2 / ds.x - 1.0f;
const float top = 1.0f - dRect.y * 2 / ds.y;
const float right = dRect.z * 2 / ds.x - 1.0f;
const float bottom = 1.0f - dRect.w * 2 / ds.y;
GSVertexPT1 vertices[] =
{
{GSVector4(left, top, 0.5f, 1.0f), GSVector2(sRect.x, sRect.y)},
{GSVector4(right, top, 0.5f, 1.0f), GSVector2(sRect.z, sRect.y)},
{GSVector4(left, bottom, 0.5f, 1.0f), GSVector2(sRect.x, sRect.w)},
{GSVector4(right, bottom, 0.5f, 1.0f), GSVector2(sRect.z, sRect.w)},
};
IASetVertexBuffer(vertices, sizeof(vertices[0]), std::size(vertices));
IASetInputLayout(m_present.il.get());
IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
// vs
VSSetShader(m_present.vs.get(), nullptr);
// gs
GSSetShader(nullptr, nullptr);
// ps
PSSetShaderResources(sTex, nullptr);
PSSetSamplerState(linear ? m_convert.ln.get() : m_convert.pt.get(), nullptr);
PSSetShader(m_present.ps[static_cast<u32>(shader)].get(), m_present.ps_cb.get());
//
DrawPrimitive();
//
EndScene();
PSSetShaderResources(nullptr, nullptr);
}
void GSDevice11::DoMerge(GSTexture* sTex[3], GSVector4* sRect, GSTexture* dTex, GSVector4* dRect, const GSRegPMODE& PMODE, const GSRegEXTBUF& EXTBUF, const GSVector4& c)
{
const GSVector4 full_r(0.0f, 0.0f, 1.0f, 1.0f);

9
pcsx2/GS/Renderers/DX11/GSDevice11.h
View File

@ -170,6 +170,14 @@ private:
wil::com_ptr_nothrow<ID3D11BlendState> bs;
} m_convert;
struct
{
wil::com_ptr_nothrow<ID3D11InputLayout> il;
wil::com_ptr_nothrow<ID3D11VertexShader> vs;
wil::com_ptr_nothrow<ID3D11PixelShader> ps[static_cast<int>(PresentShader::Count)];
wil::com_ptr_nothrow<ID3D11Buffer> ps_cb;
} m_present;
struct
{
wil::com_ptr_nothrow<ID3D11PixelShader> ps[2];
@ -257,6 +265,7 @@ public:
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, bool linear = true);
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha);
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ID3D11PixelShader* ps, ID3D11Buffer* ps_cb, ID3D11BlendState* bs, bool linear = true);
void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) override;
void SetupDATE(GSTexture* rt, GSTexture* ds, const GSVertexPT1* vertices, bool datm);

79
pcsx2/GS/Renderers/DX12/GSDevice12.cpp
View File

@ -48,11 +48,6 @@ static bool IsIntConvertShader(ShaderConvert i)
static bool IsDATMConvertShader(ShaderConvert i) { return (i == ShaderConvert::DATM_0 || i == ShaderConvert::DATM_1); }
static bool IsPresentConvertShader(ShaderConvert i)
{
return (i == ShaderConvert::COPY || (i >= ShaderConvert::SCANLINE && i <= ShaderConvert::COMPLEX_FILTER));
}
static D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE GetLoadOpForTexture(GSTexture12* tex)
{
if (!tex)
@ -157,8 +152,9 @@ bool GSDevice12::Create(HostDisplay* display)
if (!CreateBuffers())
return false;
if (!CompileConvertPipelines() || !CompileInterlacePipelines() ||
!CompileMergePipelines() || !CompilePostProcessingPipelines())
if (!CompileConvertPipelines() || !CompilePresentPipelines() ||
!CompileInterlacePipelines() || !CompileMergePipelines() ||
!CompilePostProcessingPipelines())
{
Host::ReportErrorAsync("GS", "Failed to compile utility pipelines");
return false;
@ -501,6 +497,20 @@ void GSDevice12::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
static_cast<GSTexture12*>(sTex), sRect, static_cast<GSTexture12*>(dTex), dRect, m_color_copy[index].get(), false);
}
void GSDevice12::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
PresentShader shader, float shaderTime, bool linear)
{
DisplayConstantBuffer cb;
cb.SetSource(sRect, sTex->GetSize());
cb.SetTarget(dRect, dTex ? dTex->GetSize() : GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight()));
cb.SetTime(shaderTime);
SetUtilityRootSignature();
SetUtilityPushConstants(&cb, sizeof(cb));
DoStretchRect(static_cast<GSTexture12*>(sTex), sRect, static_cast<GSTexture12*>(dTex), dRect,
m_present[static_cast<int>(shader)].get(), linear);
}
void GSDevice12::BeginRenderPassForStretchRect(GSTexture12* dTex, const GSVector4i& dtex_rc, const GSVector4i& dst_rc)
{
const bool is_whole_target = dst_rc.eq(dtex_rc);
@ -1132,17 +1142,6 @@ bool GSDevice12::CompileConvertPipelines()
D3D12::SetObjectNameFormatted(m_convert[index].get(), "Convert pipeline %d", i);
if (/*swapchain && */ IsPresentConvertShader(i))
{
// TODO: compile a present variant too
gpb.SetRenderTarget(0, DXGI_FORMAT_R8G8B8A8_UNORM);
m_present[index] = gpb.Create(g_d3d12_context->GetDevice(), m_shader_cache, false);
if (!m_present[index])
return false;
D3D12::SetObjectNameFormatted(m_present[index].get(), "Convert pipeline %d (Present)", i);
}
if (i == ShaderConvert::COPY)
{
// compile the variant for setting up hdr rendering
@ -1218,6 +1217,50 @@ bool GSDevice12::CompileConvertPipelines()
return true;
}
bool GSDevice12::CompilePresentPipelines()
{
std::optional<std::string> shader = Host::ReadResourceFileToString("shaders/dx11/present.fx");
if (!shader)
{
Host::ReportErrorAsync("GS", "Failed to read shaders/dx11/present.fx.");
return false;
}
ComPtr<ID3DBlob> m_convert_vs = GetUtilityVertexShader(*shader, "vs_main");
if (!m_convert_vs)
return false;
D3D12::GraphicsPipelineBuilder gpb;
gpb.SetRootSignature(m_utility_root_signature.get());
AddUtilityVertexAttributes(gpb);
gpb.SetNoCullRasterizationState();
gpb.SetNoBlendingState();
gpb.SetVertexShader(m_convert_vs.get());
gpb.SetDepthState(false, false, D3D12_COMPARISON_FUNC_ALWAYS);
gpb.SetNoStencilState();
gpb.SetRenderTarget(0, DXGI_FORMAT_R8G8B8A8_UNORM);
for (PresentShader i = PresentShader::COPY; static_cast<int>(i) < static_cast<int>(PresentShader::Count);
i = static_cast<PresentShader>(static_cast<int>(i) + 1))
{
const int index = static_cast<int>(i);
ComPtr<ID3DBlob> ps(GetUtilityPixelShader(*shader, shaderName(i)));
if (!ps)
return false;
gpb.SetPixelShader(ps.get());
m_present[index] = gpb.Create(g_d3d12_context->GetDevice(), m_shader_cache, false);
if (!m_present[index])
return false;
D3D12::SetObjectNameFormatted(m_present[index].get(), "Present pipeline %d", i);
}
return true;
}
bool GSDevice12::CompileInterlacePipelines()
{
std::optional<std::string> source = Host::ReadResourceFileToString("shaders/dx11/interlace.fx");

7
pcsx2/GS/Renderers/DX12/GSDevice12.h
View File

@ -114,7 +114,7 @@ public:
NUM_TFX_SAMPLERS = 2,
NUM_UTILITY_TEXTURES = 1,
NUM_UTILITY_SAMPLERS = 1,
CONVERT_PUSH_CONSTANTS_SIZE = 32,
CONVERT_PUSH_CONSTANTS_SIZE = 96,
VERTEX_BUFFER_SIZE = 32 * 1024 * 1024,
INDEX_BUFFER_SIZE = 16 * 1024 * 1024,
@ -154,7 +154,7 @@ private:
std::unordered_map<u32, D3D12::DescriptorHandle> m_samplers;
std::array<ComPtr<ID3D12PipelineState>, static_cast<int>(ShaderConvert::Count)> m_convert{};
std::array<ComPtr<ID3D12PipelineState>, static_cast<int>(ShaderConvert::Count)> m_present{};
std::array<ComPtr<ID3D12PipelineState>, static_cast<int>(PresentShader::Count)> m_present{};
std::array<ComPtr<ID3D12PipelineState>, 16> m_color_copy{};
std::array<ComPtr<ID3D12PipelineState>, 2> m_merge{};
std::array<ComPtr<ID3D12PipelineState>, 4> m_interlace{};
@ -205,6 +205,7 @@ private:
bool CreateRootSignatures();
bool CompileConvertPipelines();
bool CompilePresentPipelines();
bool CompileInterlacePipelines();
bool CompileMergePipelines();
bool CompilePostProcessingPipelines();
@ -254,6 +255,8 @@ public:
ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red,
bool green, bool blue, bool alpha) override;
void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
PresentShader shader, float shaderTime, bool linear);
void BeginRenderPassForStretchRect(GSTexture12* dTex, const GSVector4i& dtex_rc, const GSVector4i& dst_rc);
void DoStretchRect(GSTexture12* sTex, const GSVector4& sRect, GSTexture12* dTex, const GSVector4& dRect,

3
pcsx2/GS/Renderers/Metal/GSDeviceMTL.h
View File

@ -228,7 +228,7 @@ public:
// Functions and Pipeline States
MRCOwned<id<MTLRenderPipelineState>> m_convert_pipeline[static_cast<int>(ShaderConvert::Count)];
MRCOwned<id<MTLRenderPipelineState>> m_present_pipeline[static_cast<int>(ShaderConvert::Count)];
MRCOwned<id<MTLRenderPipelineState>> m_present_pipeline[static_cast<int>(PresentShader::Count)];
MRCOwned<id<MTLRenderPipelineState>> m_convert_pipeline_copy[2];
MRCOwned<id<MTLRenderPipelineState>> m_convert_pipeline_copy_mask[1 << 4];
MRCOwned<id<MTLRenderPipelineState>> m_merge_pipeline[4];
@ -356,6 +356,7 @@ public:
void RenderCopy(GSTexture* sTex, id<MTLRenderPipelineState> pipeline, const GSVector4i& rect);
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha) override;
void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) override;
void FlushClears(GSTexture* tex);

61
pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm
View File

@ -790,20 +790,12 @@ bool GSDeviceMTL::Create(HostDisplay* display)
NSString* name = [NSString stringWithCString:shaderName(conv) encoding:NSUTF8StringEncoding];
switch (conv)
{
case ShaderConvert::COPY:
case ShaderConvert::Count:
case ShaderConvert::DATM_0:
case ShaderConvert::DATM_1:
case ShaderConvert::MOD_256:
continue;
case ShaderConvert::COPY:
case ShaderConvert::SCANLINE:
case ShaderConvert::DIAGONAL_FILTER:
case ShaderConvert::TRIANGULAR_FILTER:
case ShaderConvert::COMPLEX_FILTER:
pdesc.colorAttachments[0].pixelFormat = layer_px_fmt;
pdesc.depthAttachmentPixelFormat = MTLPixelFormatInvalid;
m_present_pipeline[i] = MakePipeline(pdesc, vs_convert, LoadShader(name), [NSString stringWithFormat:@"present_%s", shaderName(conv) + 3]);
continue;
case ShaderConvert::FLOAT32_TO_32_BITS:
pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::UInt32);
pdesc.depthAttachmentPixelFormat = MTLPixelFormatInvalid;
@ -833,6 +825,13 @@ bool GSDeviceMTL::Create(HostDisplay* display)
m_convert_pipeline[i] = MakePipeline(pdesc, vs_convert, LoadShader(name), name);
}
pdesc.depthAttachmentPixelFormat = MTLPixelFormatInvalid;
for (size_t i = 0; i < std::size(m_present_pipeline); i++)
{
PresentShader conv = static_cast<PresentShader>(i);
NSString* name = [NSString stringWithCString:shaderName(conv) encoding:NSUTF8StringEncoding];
pdesc.colorAttachments[0].pixelFormat = layer_px_fmt;
m_present_pipeline[i] = MakePipeline(pdesc, vs_convert, LoadShader(name), [NSString stringWithFormat:@"present_%s", shaderName(conv) + 3]);
}
pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::Color);
m_convert_pipeline_copy[0] = MakePipeline(pdesc, vs_convert, ps_copy, @"copy_color");
pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::FloatColor);
@ -1052,16 +1051,6 @@ void GSDeviceMTL::RenderCopy(GSTexture* sTex, id<MTLRenderPipelineState> pipelin
void GSDeviceMTL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, ShaderConvert shader, bool linear)
{ @autoreleasepool {
if (!dTex)
{
// !dTex → "Present with the current draw encoder"
[m_current_render.encoder setRenderPipelineState:m_present_pipeline[static_cast<int>(shader)]];
[m_current_render.encoder setFragmentSamplerState:m_sampler_hw[linear ? SamplerSelector::Linear().key : SamplerSelector::Point().key] atIndex:0];
[m_current_render.encoder setFragmentTexture:static_cast<GSTextureMTL*>(sTex)->GetTexture() atIndex:0];
DrawStretchRect(sRect, dRect, GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight()));
return;
}
id<MTLRenderPipelineState> pipeline;
if (shader == ShaderConvert::COPY)
pipeline = m_convert_pipeline_copy[dTex->GetFormat() == GSTexture::Format::Color ? 0 : 1];
@ -1087,6 +1076,40 @@ void GSDeviceMTL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture
DoStretchRect(sTex, sRect, dTex, dRect, pipeline, false, sel == 15 ? LoadAction::DontCareIfFull : LoadAction::Load, nullptr, 0);
}}
static_assert(sizeof(DisplayConstantBuffer) == sizeof(GSMTLPresentPSUniform));
static_assert(offsetof(DisplayConstantBuffer, SourceRect) == offsetof(GSMTLPresentPSUniform, source_rect));
static_assert(offsetof(DisplayConstantBuffer, TargetRect) == offsetof(GSMTLPresentPSUniform, target_rect));
static_assert(offsetof(DisplayConstantBuffer, TargetSize) == offsetof(GSMTLPresentPSUniform, target_size));
static_assert(offsetof(DisplayConstantBuffer, TargetResolution) == offsetof(GSMTLPresentPSUniform, target_resolution));
static_assert(offsetof(DisplayConstantBuffer, RcpTargetResolution) == offsetof(GSMTLPresentPSUniform, rcp_target_resolution));
static_assert(offsetof(DisplayConstantBuffer, SourceResolution) == offsetof(GSMTLPresentPSUniform, source_resolution));
static_assert(offsetof(DisplayConstantBuffer, RcpSourceResolution) == offsetof(GSMTLPresentPSUniform, rcp_source_resolution));
static_assert(offsetof(DisplayConstantBuffer, TimeAndPad.x) == offsetof(GSMTLPresentPSUniform, time));
void GSDeviceMTL::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear)
{ @autoreleasepool {
GSVector2i ds = dTex ? dTex->GetSize() : GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight());
DisplayConstantBuffer cb;
cb.SetSource(sRect, sTex->GetSize());
cb.SetTarget(dRect, ds);
cb.SetTime(shaderTime);
id<MTLRenderPipelineState> pipe = m_present_pipeline[static_cast<int>(shader)];
if (dTex)
{
DoStretchRect(sTex, sRect, dTex, dRect, pipe, linear, LoadAction::DontCareIfFull, &cb, sizeof(cb));
}
else
{
// !dTex → Use current draw encoder
[m_current_render.encoder setRenderPipelineState:pipe];
[m_current_render.encoder setFragmentSamplerState:m_sampler_hw[linear ? SamplerSelector::Linear().key : SamplerSelector::Point().key] atIndex:0];
[m_current_render.encoder setFragmentTexture:static_cast<GSTextureMTL*>(sTex)->GetTexture() atIndex:0];
[m_current_render.encoder setFragmentBytes:&cb length:sizeof(cb) atIndex:GSMTLBufferIndexUniforms];
DrawStretchRect(sRect, dRect, ds);
}
}}
void GSDeviceMTL::FlushClears(GSTexture* tex)
{
if (tex)

13
pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h
View File

@ -39,6 +39,19 @@ struct GSMTLConvertPSUniform
int emodc;
};
struct GSMTLPresentPSUniform
{
vector_float4 source_rect;
vector_float4 target_rect;
vector_float2 source_size;
vector_float2 target_size;
vector_float2 target_resolution;
vector_float2 rcp_target_resolution; ///< 1 / target_resolution
vector_float2 source_resolution;
vector_float2 rcp_source_resolution; ///< 1 / source_resolution
float time;
};
struct GSMTLInterlacePSUniform
{
vector_float2 ZrH;

58
pcsx2/GS/Renderers/Metal/convert.metal
View File

@ -72,30 +72,6 @@ vertex ImGuiShaderData vs_imgui(ImGuiVSIn in [[stage_in]], constant float4& cb [
return out;
}
float4 ps_crt(float4 color, int i)
{
constexpr float4 mask[4] =
{
float4(1, 0, 0, 0),
float4(0, 1, 0, 0),
float4(0, 0, 1, 0),
float4(1, 1, 1, 0),
};
return color * saturate(mask[i] + 0.5f);
}
float4 ps_scanlines(float4 color, int i)
{
constexpr float4 mask[2] =
{
float4(1, 1, 1, 0),
float4(0, 0, 0, 0)
};
return color * saturate(mask[i] + 0.5f);
}
fragment float4 ps_copy(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
return res.sample(data.t);
@ -141,17 +117,6 @@ fragment float4 ps_mod256(float4 p [[position]], DirectReadTextureIn<float> tex)
return (c - 256.f * floor(c / 256.f)) / 255.f;
}
fragment float4 ps_filter_scanlines(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
return ps_scanlines(res.sample(data.t), uint(data.p.y) % 2);
}
fragment float4 ps_filter_diagonal(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
uint4 p = uint4(data.p);
return ps_crt(res.sample(data.t), (p.x + (p.y % 3)) % 3);
}
fragment float4 ps_filter_transparency(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
float4 c = res.sample(data.t);
@ -159,29 +124,6 @@ fragment float4 ps_filter_transparency(ConvertShaderData data [[stage_in]], Conv
return c;
}
fragment float4 ps_filter_triangular(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
uint4 p = uint4(data.p);
uint val = ((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3;
return ps_crt(res.sample(data.t), val);
}
fragment float4 ps_filter_complex(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
float2 texdim = float2(res.texture.get_width(), res.texture.get_height());
if (dfdy(data.t.y) * texdim.y > 0.5)
{
return res.sample(data.t);
}
else
{
float factor = (0.9f - 0.4f * cos(2.f * M_PI_F * data.t.y * texdim.y));
float ycoord = (floor(data.t.y * texdim.y) + 0.5f) / texdim.y;
return factor * res.sample(float2(data.t.x, ycoord));
}
}
fragment uint ps_convert_float32_32bits(ConvertShaderData data [[stage_in]], ConvertPSDepthRes res)
{
return uint(0x1p32 * res.sample(data.t));

80
pcsx2/GS/Renderers/Metal/present.metal Normal file
View File

@ -0,0 +1,80 @@
/* PCSX2 - PS2 Emulator for PCs
* Copyright (C) 2002-2021 PCSX2 Dev Team
*
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with PCSX2.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "GSMTLShaderCommon.h"
using namespace metal;
// use vs_convert from convert.metal
static float4 ps_crt(float4 color, int i)
{
constexpr float4 mask[4] =
{
float4(1, 0, 0, 0),
float4(0, 1, 0, 0),
float4(0, 0, 1, 0),
float4(1, 1, 1, 0),
};
return color * saturate(mask[i] + 0.5f);
}
static float4 ps_scanlines(float4 color, int i)
{
constexpr float4 mask[2] =
{
float4(1, 1, 1, 0),
float4(0, 0, 0, 0)
};
return color * saturate(mask[i] + 0.5f);
}
// use ps_copy from convert.metal
fragment float4 ps_filter_scanlines(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
return ps_scanlines(res.sample(data.t), uint(data.p.y) % 2);
}
fragment float4 ps_filter_diagonal(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
uint4 p = uint4(data.p);
return ps_crt(res.sample(data.t), (p.x + (p.y % 3)) % 3);
}
fragment float4 ps_filter_triangular(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
uint4 p = uint4(data.p);
uint val = ((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3;
return ps_crt(res.sample(data.t), val);
}
fragment float4 ps_filter_complex(ConvertShaderData data [[stage_in]], ConvertPSRes res)
{
float2 texdim = float2(res.texture.get_width(), res.texture.get_height());
if (dfdy(data.t.y) * texdim.y > 0.5)
{
return res.sample(data.t);
}
else
{
float factor = (0.9f - 0.4f * cos(2.f * M_PI_F * data.t.y * texdim.y));
float ycoord = (floor(data.t.y * texdim.y) + 0.5f) / texdim.y;
return factor * res.sample(float2(data.t.x, ycoord));
}
}

121
pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp
View File

@ -393,6 +393,43 @@ bool GSDeviceOGL::Create(HostDisplay* display)
m_convert.dss_write->SetDepth(GL_ALWAYS, true);
}
// ****************************************************************
// present
// ****************************************************************
{
GL_PUSH("GSDeviceOGL::Present");
// these all share the same vertex shader
const auto shader = Host::ReadResourceFileToString("shaders/opengl/present.glsl");
if (!shader.has_value())
{
Host::ReportErrorAsync("GS", "Failed to read shaders/opengl/present.glsl.");
return false;
}
std::string present_vs(GetShaderSource("vs_main", GL_VERTEX_SHADER, m_shader_common_header, *shader, {}));
for (size_t i = 0; i < std::size(m_present); i++)
{
const char* name = shaderName(static_cast<PresentShader>(i));
const std::string ps(GetShaderSource(name, GL_FRAGMENT_SHADER, m_shader_common_header, *shader, {}));
if (!m_shader_cache.GetProgram(&m_present[i], present_vs, {}, ps))
return false;
m_present[i].SetFormattedName("Present pipe %s", name);
// This is a bit disgusting, but it saves allocating a UBO when no shaders currently need it.
m_present[i].RegisterUniform("u_source_rect");
m_present[i].RegisterUniform("u_target_rect");
m_present[i].RegisterUniform("u_source_size");
m_present[i].RegisterUniform("u_target_size");
m_present[i].RegisterUniform("u_target_resolution");
m_present[i].RegisterUniform("u_rcp_target_resolution");
m_present[i].RegisterUniform("u_source_resolution");
m_present[i].RegisterUniform("u_rcp_source_resolution");
m_present[i].RegisterUniform("u_time");
}
}
// ****************************************************************
// merge
// ****************************************************************
@ -1202,31 +1239,18 @@ void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture
|| ps == m_convert.ps[static_cast<int>(ShaderConvert::RGBA8_TO_FLOAT16)]
|| ps == m_convert.ps[static_cast<int>(ShaderConvert::RGB5A1_TO_FLOAT16)];
// Performance optimization. It might be faster to use a framebuffer blit for standard case
// instead to emulate it with shader
// see https://www.opengl.org/wiki/Framebuffer#Blitting
// ************************************
// Init
// ************************************
BeginScene();
GSVector2i ds;
if (dTex)
{
GL_PUSH("StretchRect from %d to %d", sTex->GetID(), dTex->GetID());
ds = dTex->GetSize();
dTex->CommitRegion(GSVector2i((int)dRect.z + 1, (int)dRect.w + 1));
if (draw_in_depth)
OMSetRenderTargets(NULL, dTex);
else
OMSetRenderTargets(dTex, NULL);
}
GL_PUSH("StretchRect from %d to %d", sTex->GetID(), dTex->GetID());
dTex->CommitRegion(GSVector2i((int)dRect.z + 1, (int)dRect.w + 1));
if (draw_in_depth)
OMSetRenderTargets(NULL, dTex);
else
{
ds = GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight());
}
OMSetRenderTargets(dTex, NULL);
ps.Bind();
@ -1242,23 +1266,6 @@ void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture
OMSetBlendState(alpha_blend, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_FUNC_ADD);
OMSetColorMaskState(cms);
// ************************************
// ia
// ************************************
// Flip y axis only when we render in the backbuffer
// By default everything is render in the wrong order (ie dx).
// 1/ consistency between several pass rendering (interlace)
// 2/ in case some GS code expect thing in dx order.
// Only flipping the backbuffer is transparent (I hope)...
GSVector4 flip_sr = sRect;
if (!dTex)
{
flip_sr.y = sRect.w;
flip_sr.w = sRect.y;
}
// ************************************
// Texture
// ************************************
@ -1269,7 +1276,7 @@ void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture
// ************************************
// Draw
// ************************************
DrawStretchRect(flip_sr, dRect, ds);
DrawStretchRect(sRect, dRect, dTex->GetSize());
// ************************************
// End
@ -1278,6 +1285,48 @@ void GSDeviceOGL::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture
EndScene();
}
void GSDeviceOGL::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear)
{
ASSERT(sTex);
BeginScene();
const GSVector2i ds(dTex ? dTex->GetSize() : GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight()));
DisplayConstantBuffer cb;
cb.SetSource(sRect, sTex->GetSize());
cb.SetTarget(dRect, ds);
cb.SetTime(shaderTime);
GL::Program& prog = m_present[static_cast<int>(shader)];
prog.Bind();
prog.Uniform4fv(0, cb.SourceRect.F32);
prog.Uniform4fv(1, cb.TargetRect.F32);
prog.Uniform2fv(2, &cb.SourceSize.x);
prog.Uniform2fv(3, &cb.TargetSize.x);
prog.Uniform2fv(4, &cb.TargetResolution.x);
prog.Uniform2fv(5, &cb.RcpTargetResolution.x);
prog.Uniform2fv(6, &cb.SourceResolution.x);
prog.Uniform2fv(7, &cb.RcpSourceResolution.x);
prog.Uniform1f(8, cb.TimeAndPad.x);
OMSetDepthStencilState(m_convert.dss);
OMSetBlendState(false);
OMSetColorMaskState();
PSSetShaderResource(0, sTex);
PSSetSamplerState(linear ? m_convert.ln : m_convert.pt);
// Flip y axis only when we render in the backbuffer
// By default everything is render in the wrong order (ie dx).
// 1/ consistency between several pass rendering (interlace)
// 2/ in case some GS code expect thing in dx order.
// Only flipping the backbuffer is transparent (I hope)...
const GSVector4 flip_sr(sRect.xwzy());
DrawStretchRect(flip_sr, dRect, ds);
EndScene();
}
void GSDeviceOGL::DrawStretchRect(const GSVector4& sRect, const GSVector4& dRect, const GSVector2i& ds)
{
// Original code from DX

3
pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.h
View File

@ -255,6 +255,8 @@ private:
GSDepthStencilOGL* dss_write = nullptr;
} m_convert;
GL::Program m_present[static_cast<int>(PresentShader::Count)];
struct
{
GL::Program ps;
@ -354,6 +356,7 @@ public:
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GL::Program& ps, bool linear = true);
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red, bool green, bool blue, bool alpha) final;
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, const GL::Program& ps, bool alpha_blend, OMColorMaskSelector cms, bool linear = true);
void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, PresentShader shader, float shaderTime, bool linear) final;
void RenderHW(GSHWDrawConfig& config) final;
void SendHWDraw(const GSHWDrawConfig& config, bool needs_barrier);

100
pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp
View File

@ -51,11 +51,6 @@ static bool IsIntConvertShader(ShaderConvert i)
static bool IsDATMConvertShader(ShaderConvert i) { return (i == ShaderConvert::DATM_0 || i == ShaderConvert::DATM_1); }
static bool IsPresentConvertShader(ShaderConvert i)
{
return (i == ShaderConvert::COPY || (i >= ShaderConvert::SCANLINE && i <= ShaderConvert::COMPLEX_FILTER));
}
static VkAttachmentLoadOp GetLoadOpForTexture(GSTextureVK* tex)
{
if (!tex)
@ -120,8 +115,9 @@ bool GSDeviceVK::Create(HostDisplay* display)
if (!CreateBuffers())
return false;
if (!CompileConvertPipelines() || !CompileInterlacePipelines() ||
!CompileMergePipelines() || !CompilePostProcessingPipelines())
if (!CompileConvertPipelines() || !CompilePresentPipelines() ||
!CompileInterlacePipelines() || !CompileMergePipelines() ||
!CompilePostProcessingPipelines())
{
Host::ReportErrorAsync("GS", "Failed to compile utility pipelines");
return false;
@ -584,6 +580,19 @@ void GSDeviceVK::StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture*
static_cast<GSTextureVK*>(sTex), sRect, static_cast<GSTextureVK*>(dTex), dRect, m_color_copy[index], false);
}
void GSDeviceVK::PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
PresentShader shader, float shaderTime, bool linear)
{
DisplayConstantBuffer cb;
cb.SetSource(sRect, sTex->GetSize());
cb.SetTarget(dRect, dTex ? dTex->GetSize() : GSVector2i(m_display->GetWindowWidth(), m_display->GetWindowHeight()));
cb.SetTime(shaderTime);
SetUtilityPushConstants(&cb, sizeof(cb));
DoStretchRect(static_cast<GSTextureVK*>(sTex), sRect, static_cast<GSTextureVK*>(dTex), dRect,
m_present[static_cast<int>(shader)], linear);
}
void GSDeviceVK::BeginRenderPassForStretchRect(GSTextureVK* dTex, const GSVector4i& dtex_rc, const GSVector4i& dst_rc)
{
const bool is_whole_target = dst_rc.eq(dtex_rc);
@ -1397,19 +1406,6 @@ bool GSDeviceVK::CompileConvertPipelines()
Vulkan::Util::SetObjectName(g_vulkan_context->GetDevice(), m_convert[index], "Convert pipeline %d", i);
if (swapchain && IsPresentConvertShader(i))
{
// compile a present variant too
gpb.SetRenderPass(m_swap_chain_render_pass, 0);
m_present[index] =
gpb.Create(g_vulkan_context->GetDevice(), g_vulkan_shader_cache->GetPipelineCache(true), false);
if (!m_present[index])
return false;
Vulkan::Util::SetObjectName(
g_vulkan_context->GetDevice(), m_present[index], "Convert pipeline %d (Present)", i);
}
if (i == ShaderConvert::COPY)
{
// compile the variant for setting up hdr rendering
@ -1519,6 +1515,70 @@ bool GSDeviceVK::CompileConvertPipelines()
return true;
}
bool GSDeviceVK::CompilePresentPipelines()
{
// we may not have a swap chain if running in headless mode.
Vulkan::SwapChain* swapchain = static_cast<Vulkan::SwapChain*>(m_display->GetRenderSurface());
if (swapchain)
{
m_swap_chain_render_pass =
g_vulkan_context->GetRenderPass(swapchain->GetSurfaceFormat().format, VK_FORMAT_UNDEFINED);
if (!m_swap_chain_render_pass)
return false;
}
std::optional<std::string> shader = Host::ReadResourceFileToString("shaders/vulkan/present.glsl");
if (!shader)
{
Host::ReportErrorAsync("GS", "Failed to read shaders/vulkan/present.glsl.");
return false;
}
VkShaderModule vs = GetUtilityVertexShader(*shader);
if (vs == VK_NULL_HANDLE)
return false;
ScopedGuard vs_guard([&vs]() { Vulkan::Util::SafeDestroyShaderModule(vs); });
Vulkan::GraphicsPipelineBuilder gpb;
AddUtilityVertexAttributes(gpb);
gpb.SetPipelineLayout(m_utility_pipeline_layout);
gpb.SetDynamicViewportAndScissorState();
gpb.AddDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS);
gpb.SetNoCullRasterizationState();
gpb.SetNoBlendingState();
gpb.SetVertexShader(vs);
gpb.SetDepthState(false, false, VK_COMPARE_OP_ALWAYS);
gpb.SetNoStencilState();
gpb.SetRenderPass(m_swap_chain_render_pass, 0);
// we enable provoking vertex here anyway, in case it doesn't support multiple modes in the same pass
if (m_features.provoking_vertex_last)
gpb.SetProvokingVertex(VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT);
for (PresentShader i = PresentShader::COPY; static_cast<int>(i) < static_cast<int>(PresentShader::Count);
i = static_cast<PresentShader>(static_cast<int>(i) + 1))
{
const int index = static_cast<int>(i);
VkShaderModule ps = GetUtilityFragmentShader(*shader, shaderName(i));
if (ps == VK_NULL_HANDLE)
return false;
ScopedGuard ps_guard([&ps]() { Vulkan::Util::SafeDestroyShaderModule(ps); });
gpb.SetFragmentShader(ps);
m_present[index] =
gpb.Create(g_vulkan_context->GetDevice(), g_vulkan_shader_cache->GetPipelineCache(true), false);
if (!m_present[index])
return false;
Vulkan::Util::SetObjectName(g_vulkan_context->GetDevice(), m_present[index], "Present pipeline %d", i);
}
return true;
}
bool GSDeviceVK::CompileInterlacePipelines()
{
std::optional<std::string> shader = Host::ReadResourceFileToString("shaders/vulkan/interlace.glsl");

7
pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h
View File

@ -77,7 +77,7 @@ public:
NUM_TFX_TEXTURES = NUM_TFX_SAMPLERS + NUM_TFX_RT_TEXTURES,
NUM_CONVERT_TEXTURES = 1,
NUM_CONVERT_SAMPLERS = 1,
CONVERT_PUSH_CONSTANTS_SIZE = 32,
CONVERT_PUSH_CONSTANTS_SIZE = 96,
VERTEX_BUFFER_SIZE = 32 * 1024 * 1024,
INDEX_BUFFER_SIZE = 16 * 1024 * 1024,
@ -116,7 +116,7 @@ private:
std::unordered_map<u32, VkSampler> m_samplers;
std::array<VkPipeline, static_cast<int>(ShaderConvert::Count)> m_convert{};
std::array<VkPipeline, static_cast<int>(ShaderConvert::Count)> m_present{};
std::array<VkPipeline, static_cast<int>(PresentShader::Count)> m_present{};
std::array<VkPipeline, 16> m_color_copy{};
std::array<VkPipeline, 2> m_merge{};
std::array<VkPipeline, 4> m_interlace{};
@ -177,6 +177,7 @@ private:
bool CreateRenderPasses();
bool CompileConvertPipelines();
bool CompilePresentPipelines();
bool CompileInterlacePipelines();
bool CompileMergePipelines();
bool CompilePostProcessingPipelines();
@ -229,6 +230,8 @@ public:
ShaderConvert shader = ShaderConvert::COPY, bool linear = true) override;
void StretchRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect, bool red,
bool green, bool blue, bool alpha) override;
void PresentRect(GSTexture* sTex, const GSVector4& sRect, GSTexture* dTex, const GSVector4& dRect,
PresentShader shader, float shaderTime, bool linear) override;
void BeginRenderPassForStretchRect(GSTextureVK* dTex, const GSVector4i& dtex_rc, const GSVector4i& dst_rc);
void DoStretchRect(GSTextureVK* sTex, const GSVector4& sRect, GSTextureVK* dTex, const GSVector4& dRect,