ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dolphin/Source/Core/VideoCommon/TextureConversionShader.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1221 lines
41 KiB
C++
Raw Normal View History

Set copyright year to when a file was created
2015-05-24 04:55:12 +00:00
// Copyright 2009 Dolphin Emulator Project
treewide: convert GPLv2+ license info to SPDX tags SPDX standardizes how source code conveys its copyright and licensing information. See https://spdx.github.io/spdx-spec/1-rationale/ . SPDX tags are adopted in many large projects, including things like the Linux kernel.
2021-07-05 01:22:19 +00:00
// SPDX-License-Identifier: GPL-2.0-or-later
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
#include "VideoCommon/TextureConversionShader.h"
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
#include <map>
#include <sstream>
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
#include <string_view>
Some housecleaning around the D3D plugin, start of preparations to share even more code with the GL plugin. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4183 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-09-03 19:24:16 +00:00
VideoCommon: Header cleanup Also remedies places where the video backends and core rely on things being indirectly included.
2016-01-17 21:54:31 +00:00
#include "Common/CommonTypes.h"
Fixes include order of TextureConversionShader.cpp
2014-03-08 23:38:29 +00:00
#include "Common/MathUtil.h"
VideoCommon: Header cleanup Also remedies places where the video backends and core rely on things being indirectly included.
2016-01-17 21:54:31 +00:00
#include "Common/MsgHandler.h"
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
#include "VideoCommon/ShaderGenCommon.h"
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
#include "VideoCommon/TextureCacheBase.h"
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#include "VideoCommon/VertexManagerBase.h"
VideoCommon: Make API_TYPE an enum class Allows for forward declarations in most places, which prevents dumping unrelated VideoCommon.h contents directly into headers.
2016-07-21 23:04:57 +00:00
#include "VideoCommon/VideoCommon.h"
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#include "VideoCommon/VideoConfig.h"
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon: Rename TextureConversionShader namespace.
2017-11-25 10:13:22 +00:00
namespace TextureConversionShaderTiled
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
u16 GetEncodedSampleCount(EFBCopyFormat format)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
switch (format)
{
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::R4:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 8;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RA4:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 4;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RA8:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 2;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RGB565:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 2;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RGB5A3:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 2;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RGBA8:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 1;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::A8:
case EFBCopyFormat::R8_0x1:
case EFBCopyFormat::R8:
case EFBCopyFormat::G8:
case EFBCopyFormat::B8:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 4;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RG8:
case EFBCopyFormat::GB8:
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 2;
Add support for hybrid XFB
2017-05-29 22:02:09 +00:00
case EFBCopyFormat::XFB:
return 2;
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
default:
Remove casts to integers for texture and EFB formats The only remaining casts for these types that I know of are in TextureInfo (where format_name is set to the int version of the format, and since that affects filenames and probably would break resource packs, I'm not changing it) and in TextureDecoder_Common's TexDecoder_DrawOverlay, which will be handled separately.
2022-02-23 02:01:39 +00:00
PanicAlertFmt("Invalid EFB Copy Format {}! (GetEncodedSampleCount)", format);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
return 1;
}
}
fix formatting uglies introduced in glsl-master branch
2011-12-26 05:15:54 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
static void WriteHeader(ShaderCode& code, APIType api_type)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
// left, top, of source rectangle within source texture
// width of the destination rectangle, scale_factor (1 or 2)
code.Write("UBO_BINDING(std140, 1) uniform PSBlock {{\n"
" int4 position;\n"
" float y_scale;\n"
" float gamma_rcp;\n"
" float2 clamp_tb;\n"
Restructure parameters to TetxureConverterShaderGen/TextureConversionShader This will be used for later refactoring for increased accuracy.
2022-02-07 21:37:28 +00:00
" uint3 filter_coefficients;\n"
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
"}};\n");
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
Video Backends: Implement vertical scaling for xfb copies. This fixes the display of PAL games that run in 50hz mode.
2017-07-03 02:24:20 +00:00
{
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
code.Write("VARYING_LOCATION(0) in VertexData {{\n"
" float3 v_tex0;\n"
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
"}};\n");
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
}
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
else
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
{
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
code.Write("VARYING_LOCATION(0) in float3 v_tex0;\n");
Video Backends: Implement vertical scaling for xfb copies. This fixes the display of PAL games that run in 50hz mode.
2017-07-03 02:24:20 +00:00
}
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
code.Write("SAMPLER_BINDING(0) uniform sampler2DArray samp0;\n"
"FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\n");
TextureConversionShader: Use round() instead of roundEven() in HLSL HLSL does not define roundEven(), only round(). This means that the output may differ slightly for OpenGL vs Direct3D. However, it ensures consistency across OpenGL drivers, as round() in GLSL can go either way.
2017-12-05 17:08:35 +00:00
TextureConversionShader: Use integer math for truncating EFB format
2017-04-25 03:02:34 +00:00
// Alpha channel in the copy is set to 1 the EFB format does not have an alpha channel.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("float4 RGBA8ToRGB8(float4 src)\n"
"{{\n"
" return float4(src.xyz, 1.0);\n"
"}}\n"
"float4 RGBA8ToRGBA6(float4 src)\n"
"{{\n"
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
" int4 val = int4(roundEven(src * 255.0));\n"
" val = (val & 0xfc) | (val >> 6);\n"
" return float4(val) / 255.0;\n"
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
"}}\n"
"float4 RGBA8ToRGB565(float4 src)\n"
"{{\n"
" int4 val = int4(roundEven(src * 255.0));\n"
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
" val.r = (val.r & 0xf8) | (val.r >> 5);\n"
" val.g = (val.g & 0xfc) | (val.g >> 6);\n"
" val.b = (val.b & 0xf8) | (val.b >> 5);\n"
" val.a = 255;\n"
" return float4(val) / 255.0;\n"
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
"}}\n");
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
}
TextureConversionShader: Use integer math for truncating EFB format
2017-04-25 03:02:34 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
static void WriteSampleFunction(ShaderCode& code, const EFBCopyParams& params, APIType api_type)
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
{
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write("uint4 SampleEFB0(float2 uv, float2 pixel_size, float x_offset, float y_offset) {{\n"
" float4 tex_sample = texture(samp0, float3(uv.x + x_offset * pixel_size.x, ");
// Reverse the direction for OpenGL, since positive numbers are distance from the bottom row.
// TODO: This isn't done on TextureConverterShaderGen - maybe it handles that via pixel_size?
if (api_type == APIType::OpenGL)
code.Write("clamp(uv.y - y_offset * pixel_size.y, clamp_tb.x, clamp_tb.y)");
else
code.Write("clamp(uv.y + y_offset * pixel_size.y, clamp_tb.x, clamp_tb.y)");
code.Write(", 0.0));\n");
// TODO: Is this really needed? Doesn't the EFB only store appropriate values? Or is this for
// EFB2Ram having consistent output with force 32-bit color?
if (params.efb_format == PixelFormat::RGB8_Z24)
code.Write(" tex_sample = RGBA8ToRGB8(tex_sample);\n");
else if (params.efb_format == PixelFormat::RGBA6_Z24)
code.Write(" tex_sample = RGBA8ToRGBA6(tex_sample);\n");
else if (params.efb_format == PixelFormat::RGB565_Z16)
code.Write(" tex_sample = RGBA8ToRGB565(tex_sample);\n");
if (params.depth)
{
if (!g_ActiveConfig.backend_info.bSupportsReversedDepthRange)
code.Write(" tex_sample.x = 1.0 - tex_sample.x;\n");
code.Write(" uint depth = uint(tex_sample.x * 16777216.0);\n"
" return uint4((depth >> 16) & 255u, (depth >> 8) & 255u, depth & 255u, 255u);\n"
"}}\n");
}
else
{
code.Write(" return uint4(tex_sample * 255.0);\n"
"}}\n");
}
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
// The copy filter applies to both color and depth copies. This has been verified on hardware.
// The filter is only applied to the RGB channels, the alpha channel is left intact.
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write("float4 SampleEFB(float2 uv, float2 pixel_size, int x_offset)\n"
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
"{{\n");
Restructure parameters to TetxureConverterShaderGen/TextureConversionShader This will be used for later refactoring for increased accuracy.
2022-02-07 21:37:28 +00:00
if (params.all_copy_filter_coefs_needed)
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
{
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write(" uint4 prev_row = SampleEFB0(uv, pixel_size, float(x_offset), -1.0f);\n"
" uint4 current_row = SampleEFB0(uv, pixel_size, float(x_offset), 0.0f);\n"
" uint4 next_row = SampleEFB0(uv, pixel_size, float(x_offset), 1.0f);\n"
" uint3 combined_rows = prev_row.rgb * filter_coefficients[0] +\n"
" current_row.rgb * filter_coefficients[1] +\n"
" next_row.rgb * filter_coefficients[2];\n");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
}
else
{
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write(" uint4 current_row = SampleEFB0(uv, pixel_size, float(x_offset), 0.0f);\n"
" uint3 combined_rows = current_row.rgb * filter_coefficients[1];\n");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
}
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write(" // Shift right by 6 to divide by 64, as filter coefficients\n"
" // that sum to 64 result in no change in brightness\n"
" uint4 texcol_raw = uint4(combined_rows.rgb >> 6, current_row.a);\n");
if (params.copy_filter_can_overflow)
code.Write(" texcol_raw &= 0x1ffu;\n");
// Note that overflow occurs when the sum of values is >= 128, but this max situation can be hit
// on >= 64, so we always include it.
code.Write(" texcol_raw = min(texcol_raw, uint4(255, 255, 255, 255));\n");
if (params.apply_gamma)
{
code.Write(" texcol_raw = uint4(round(pow(float4(texcol_raw) / 255.0,\n"
" float4(gamma_rcp, gamma_rcp, gamma_rcp, 1.0)) * 255.0));\n");
}
if (params.yuv)
{
code.Write(" // Intensity/YUV format conversion constants determined by hardware testing\n"
" const float4 y_const = float4( 66, 129, 25, 16);\n"
" const float4 u_const = float4(-38, -74, 112, 128);\n"
" const float4 v_const = float4(112, -94, -18, 128);\n"
" // Intensity/YUV format conversion\n"
" texcol_raw.rgb = uint3(dot(y_const, float4(texcol_raw.rgb, 256)),\n"
" dot(u_const, float4(texcol_raw.rgb, 256)),\n"
" dot(v_const, float4(texcol_raw.rgb, 256)));\n"
" // Divide by 256 and round .5 and higher up\n"
Fix OpenGL error on M1 Mac. Followup to #10466. Resolves the following error: ERROR: 0:85: '&' does not operate on 'uvec3' and 'int'
2022-07-17 12:53:43 +00:00
" texcol_raw.rgb = (texcol_raw.rgb >> 8) + ((texcol_raw.rgb >> 7) & 1u);\n");
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
}
code.Write(" return float4(texcol_raw) / 255.0;\n");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("}}\n");
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
}
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// Block dimensions : widthStride, heightStride
// Texture dimensions : width, height, x offset, y offset
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
static void WriteSwizzler(ShaderCode& code, const EFBCopyParams& params, APIType api_type)
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
{
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
code.Write("void main()\n"
"{{\n"
" int2 sampleUv;\n"
" int2 uv1 = int2(gl_FragCoord.xy);\n");
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +00:00
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
const int blkW = TexDecoder_GetEFBCopyBlockWidthInTexels(params.copy_format);
const int blkH = TexDecoder_GetEFBCopyBlockHeightInTexels(params.copy_format);
int samples = GetEncodedSampleCount(params.copy_format);
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
Common/MathUtil: Move IntLog2 into MathUtil namespace Gets this out of the global namespace.
2023-04-15 07:27:35 +00:00
code.Write(" int x_block_position = (uv1.x >> {}) << {};\n",
MathUtil::IntLog2(blkH * blkW / samples), MathUtil::IntLog2(blkW));
code.Write(" int y_block_position = uv1.y << {};\n", MathUtil::IntLog2(blkH));
Rewrite texture tiling implementation inline halfxb So we know which is the first pixel by masking. inline xl inline xb a bit inline yl inline uv1.x shift remove likely wrong guessed ternary operator add pixel layout comment inline xel optimize the shifts a bit inline xb optimize shifts in a second step extract xb rename all variables calculate cache line by position.x Revert 5115b459f40d53044cd7a858f52e6e876e1211b4 "optimize the shifts a bit" It seems I was wrong, the other way is the more natural. use x_virtual_position instead of uv1.x for x_offset_in_block This looks more natural and the offset should be masked anyway. substitude factor with cache_lines move 32bit logic in a conditional block
2014-02-24 15:15:44 +00:00
if (samples == 1)
{
Fix RGBA8 encoding.
2015-01-26 06:53:30 +00:00
// With samples == 1, we write out pairs of blocks; one A8R8, one G8B8.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" bool first = (uv1.x & {}) == 0;\n", blkH * blkW / 2);
Fix RGBA8 encoding.
2015-01-26 06:53:30 +00:00
samples = 2;
Rewrite texture tiling implementation inline halfxb So we know which is the first pixel by masking. inline xl inline xb a bit inline yl inline uv1.x shift remove likely wrong guessed ternary operator add pixel layout comment inline xel optimize the shifts a bit inline xb optimize shifts in a second step extract xb rename all variables calculate cache line by position.x Revert 5115b459f40d53044cd7a858f52e6e876e1211b4 "optimize the shifts a bit" It seems I was wrong, the other way is the more natural. use x_virtual_position instead of uv1.x for x_offset_in_block This looks more natural and the offset should be masked anyway. substitude factor with cache_lines move 32bit logic in a conditional block
2014-02-24 15:15:44 +00:00
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" int offset_in_block = uv1.x & {};\n", (blkH * blkW / samples) - 1);
Common/MathUtil: Move IntLog2 into MathUtil namespace Gets this out of the global namespace.
2023-04-15 07:27:35 +00:00
code.Write(" int y_offset_in_block = offset_in_block >> {};\n",
MathUtil::IntLog2(blkW / samples));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" int x_offset_in_block = (offset_in_block & {}) << {};\n", (blkW / samples) - 1,
Common/MathUtil: Move IntLog2 into MathUtil namespace Gets this out of the global namespace.
2023-04-15 07:27:35 +00:00
MathUtil::IntLog2(samples));
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" sampleUv.x = x_block_position + x_offset_in_block;\n"
" sampleUv.y = y_block_position + y_offset_in_block;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// sampleUv is the sample position in (int)gx_coords
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float2 uv0 = float2(sampleUv);\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// Move to center of pixel
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" uv0 += float2(0.5, 0.5);\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// Scale by two if needed (also move to pixel borders
// so that linear filtering will average adjacent
// pixel)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" uv0 *= float(position.w);\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// Move to copied rect
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" uv0 += float2(position.xy);\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// Normalize to [0:1]
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" uv0 /= float2({}, {});\n", EFB_WIDTH, EFB_HEIGHT);
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// Apply the y scaling
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" uv0 /= float2(1, y_scale);\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
// OGL has to flip up and down
if (api_type == APIType::OpenGL)
comment fixes
2014-02-26 11:48:52 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" uv0.y = 1.0-uv0.y;\n");
comment fixes
2014-02-26 11:48:52 +00:00
}
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float2 pixel_size = float2(position.w, position.w) / float2({}, {});\n", EFB_WIDTH,
EFB_HEIGHT);
Changing where depth is read. Trying to use the same depth buffer GL uses when copying depth to a texture. This eliminates some quirky code and gets depth copies working in AA, but may not work on older graphics cards. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@3234 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-05-15 02:39:55 +00:00
}
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
static void WriteSampleColor(ShaderCode& code, std::string_view color_comp, std::string_view dest,
int x_offset, APIType api_type, const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" {} = SampleEFB(uv0, pixel_size, {}).{};\n", dest, x_offset, color_comp);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
static void WriteToBitDepth(ShaderCode& code, u8 depth, std::string_view src, std::string_view dest)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" {} = floor({} * 255.0 / exp2(8.0 - {}.0));\n", dest, src, depth);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
static void WriteRGB565Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float3 texSample0;\n"
" float3 texSample1;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, "rgb", "texSample0", 0, api_type, params);
WriteSampleColor(code, "rgb", "texSample1", 1, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float2 texRs = float2(texSample0.r, texSample1.r);\n"
" float2 texGs = float2(texSample0.g, texSample1.g);\n"
" float2 texBs = float2(texSample0.b, texSample1.b);\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 6, "texGs", "float2 gInt");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float2 gUpper = floor(gInt / 8.0);\n"
" float2 gLower = gInt - gUpper * 8.0;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texRs", "ocol0.br");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0.br = ocol0.br * 8.0 + gUpper;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texBs", "ocol0.ga");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0.ga = ocol0.ga + gLower * 32.0;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0 = ocol0 / 255.0;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
}
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
static void WriteRGB5A3Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float4 texSample;\n"
" float color0;\n"
" float gUpper;\n"
" float gLower;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, "rgba", "texSample", 0, api_type, params);
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
// 0.8784 = 224 / 255 which is the maximum alpha value that can be represented in 3 bits
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("if(texSample.a > 0.878f) {{\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texSample.g", "color0");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" gUpper = floor(color0 / 8.0);\n"
" gLower = color0 - gUpper * 8.0;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texSample.r", "ocol0.b");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0.b = ocol0.b * 4.0 + gUpper + 128.0;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texSample.b", "ocol0.g");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0.g = ocol0.g + gLower * 32.0;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("}} else {{\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 4, "texSample.r", "ocol0.b");
WriteToBitDepth(code, 4, "texSample.b", "ocol0.g");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 3, "texSample.a", "color0");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("ocol0.b = ocol0.b + color0 * 16.0;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 4, "texSample.g", "color0");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("ocol0.g = ocol0.g + color0 * 16.0;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("}}\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, "rgba", "texSample", 1, api_type, params);
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("if(texSample.a > 0.878f) {{\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texSample.g", "color0");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" gUpper = floor(color0 / 8.0);\n"
" gLower = color0 - gUpper * 8.0;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texSample.r", "ocol0.r");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0.r = ocol0.r * 4.0 + gUpper + 128.0;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 5, "texSample.b", "ocol0.a");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0.a = ocol0.a + gLower * 32.0;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("}} else {{\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 4, "texSample.r", "ocol0.r");
WriteToBitDepth(code, 4, "texSample.b", "ocol0.a");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 3, "texSample.a", "color0");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("ocol0.r = ocol0.r + color0 * 16.0;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 4, "texSample.g", "color0");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("ocol0.a = ocol0.a + color0 * 16.0;\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write("}}\n");
Fixed the way a format was converted from the EFB to ram. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2723 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 03:25:59 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0 = ocol0 / 255.0;\n");
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
static void WriteRGBA8Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float4 texSample;\n"
" float4 color0;\n"
" float4 color1;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, "rgba", "texSample", 0, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" color0.b = texSample.a;\n"
" color0.g = texSample.r;\n"
" color1.b = texSample.g;\n"
" color1.g = texSample.b;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, "rgba", "texSample", 1, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" color0.r = texSample.a;\n"
" color0.a = texSample.r;\n"
" color1.r = texSample.g;\n"
" color1.a = texSample.b;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0 = first ? color0 : color1;\n");
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
static void WriteC4Encoder(ShaderCode& code, std::string_view comp, APIType api_type,
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float4 color0;\n"
" float4 color1;\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "color0.b", 0, api_type, params);
WriteSampleColor(code, comp, "color1.b", 1, api_type, params);
WriteSampleColor(code, comp, "color0.g", 2, api_type, params);
WriteSampleColor(code, comp, "color1.g", 3, api_type, params);
WriteSampleColor(code, comp, "color0.r", 4, api_type, params);
WriteSampleColor(code, comp, "color1.r", 5, api_type, params);
WriteSampleColor(code, comp, "color0.a", 6, api_type, params);
WriteSampleColor(code, comp, "color1.a", 7, api_type, params);
WriteToBitDepth(code, 4, "color0", "color0");
WriteToBitDepth(code, 4, "color1", "color1");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0 = (color0 * 16.0 + color1) / 255.0;\n");
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
static void WriteC8Encoder(ShaderCode& code, std::string_view comp, APIType api_type,
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "ocol0.b", 0, api_type, params);
WriteSampleColor(code, comp, "ocol0.g", 1, api_type, params);
WriteSampleColor(code, comp, "ocol0.r", 2, api_type, params);
WriteSampleColor(code, comp, "ocol0.a", 3, api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
static void WriteCC4Encoder(ShaderCode& code, std::string_view comp, APIType api_type,
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" float2 texSample;\n"
" float4 color0;\n"
" float4 color1;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "texSample", 0, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" color0.b = texSample.x;\n"
" color1.b = texSample.y;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "texSample", 1, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" color0.g = texSample.x;\n"
" color1.g = texSample.y;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "texSample", 2, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" color0.r = texSample.x;\n"
" color1.r = texSample.y;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "texSample", 3, api_type, params);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" color0.a = texSample.x;\n"
" color1.a = texSample.y;\n");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteToBitDepth(code, 4, "color0", "color0");
WriteToBitDepth(code, 4, "color1", "color1");
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 07:23:32 +00:00
code.Write(" ocol0 = (color0 * 16.0 + color1) / 255.0;\n");
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon/TextureConversionShader: Make use of fmt where applicable Now that we've converted the shader generation over to ShaderCode, we can now make use of the fmt-capable WriteFmt function.
2020-01-23 19:11:28 +00:00
static void WriteCC8Encoder(ShaderCode& code, std::string_view comp, APIType api_type,
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
const EFBCopyParams& params)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteSampleColor(code, comp, "ocol0.bg", 0, api_type, params);
WriteSampleColor(code, comp, "ocol0.ra", 1, api_type, params);
Changing where depth is read. Trying to use the same depth buffer GL uses when copying depth to a texture. This eliminates some quirky code and gets depth copies working in AA, but may not work on older graphics cards. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@3234 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-05-15 02:39:55 +00:00
}
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
static void WriteXFBEncoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
Add support for hybrid XFB
2017-05-29 22:02:09 +00:00
{
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write("float4 color0 = float4(0, 0, 0, 1), color1 = float4(0, 0, 0, 1);\n");
WriteSampleColor(code, "rgb", "color0.rgb", 0, api_type, params);
WriteSampleColor(code, "rgb", "color1.rgb", 1, api_type, params);
Implement EFB copy filter and gamma in hardware backends Also makes y_scale a dynamic parameter for EFB copies, as it doesn't make sense to keep it as part of the uid, otherwise we're generating redundant shaders.
2018-04-29 08:52:30 +00:00
// Convert to YUV.
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write(" // Intensity/YUV format conversion constants determined by hardware testing\n"
" const float4 y_const = float4( 66, 129, 25, 16);\n"
" const float4 u_const = float4(-38, -74, 112, 128);\n"
" const float4 v_const = float4(112, -94, -18, 128);\n"
" float4 average = (color0 + color1) * 0.5;\n"
" // TODO: check rounding\n"
" ocol0.b = round(dot(color0, y_const)) / 256.0;\n"
" ocol0.g = round(dot(average, u_const)) / 256.0;\n"
" ocol0.r = round(dot(color1, y_const)) / 256.0;\n"
" ocol0.a = round(dot(average, v_const)) / 256.0;\n");
Add support for hybrid XFB
2017-05-29 22:02:09 +00:00
}
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
std::string GenerateEncodingShader(const EFBCopyParams& params, APIType api_type)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
ShaderCode code;
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +00:00
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteHeader(code, api_type);
WriteSampleFunction(code, params, api_type);
WriteSwizzler(code, params, api_type);
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
switch (params.copy_format)
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
{
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::R4:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteC4Encoder(code, "r", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RA4:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteCC4Encoder(code, "ar", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RA8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteCC8Encoder(code, "ar", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RGB565:
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteRGB565Encoder(code, api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RGB5A3:
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteRGB5A3Encoder(code, api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RGBA8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteRGBA8Encoder(code, api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::A8:
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteC8Encoder(code, "a", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::R8_0x1:
case EFBCopyFormat::R8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteC8Encoder(code, "r", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::G8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteC8Encoder(code, "g", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::B8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteC8Encoder(code, "b", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::RG8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteCC8Encoder(code, "gr", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
case EFBCopyFormat::GB8:
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
WriteCC8Encoder(code, "bg", api_type, params);
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
break;
Add support for hybrid XFB
2017-05-29 22:02:09 +00:00
case EFBCopyFormat::XFB:
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
WriteXFBEncoder(code, api_type, params);
Add support for hybrid XFB
2017-05-29 22:02:09 +00:00
break;
EFB to ram scales correctly non-native resolutions. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2724 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-03-22 09:00:43 +00:00
default:
Remove casts to integers for texture and EFB formats The only remaining casts for these types that I know of are in TextureInfo (where format_name is set to the int version of the format, and since that affects filenames and probably would break resource packs, I'm not changing it) and in TextureDecoder_Common's TexDecoder_DrawOverlay, which will be handled separately.
2022-02-23 02:01:39 +00:00
PanicAlertFmt("Invalid EFB Copy Format {}! (GenerateEncodingShader)", params.copy_format);
Shader generators: Remove any references to D3D9 and cleanup the affected code.
2013-09-22 16:07:21 +00:00
break;
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +00:00
Rework TextureConversionShader for hardware accuracy and simplicity
2022-02-23 04:36:11 +00:00
code.Write("}}\n");
VideoCommon/TextureConversionShader: Convert over to using ShaderCode Migrates the shader generator off the use of a global array, eliminating the use of some global state. This also allows us to move the shader generation over to using fmt in a subsequent change.
2020-01-23 18:06:55 +00:00
return code.GetBuffer();
added an option to copy textures from the EFB to system memory. this is slower but shouldn't cause the compatibility issues the previous method of copying them directly to a GL texture has. the new method can be tested by disabling "copy EFB to texture" in the hacks section. the new method still needs some tweaks. fixed some off-by-one errors in the EFB to texture copy and the scissor box. also fixed a couple asserts I was getting in the volume directory stuff. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1853 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-01-11 22:25:57 +00:00
}
Update svn:eol-style=native ( r1442 ) for Source/*.cpp git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2384 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-02-23 06:15:48 +00:00
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// NOTE: In these uniforms, a row refers to a row of blocks, not texels.
static const char decoding_shader_header[] = R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#if defined(PALETTE_FORMAT_IA8) || defined(PALETTE_FORMAT_RGB565) || defined(PALETTE_FORMAT_RGB5A3)
#define HAS_PALETTE 1
#endif
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
UBO_BINDING(std140, 1) uniform UBO {
uint2 u_dst_size;
uint2 u_src_size;
uint u_src_offset;
uint u_src_row_stride;
uint u_palette_offset;
};
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
#if defined(API_METAL)
#if defined(TEXEL_BUFFER_FORMAT_R8)
SSBO_BINDING(0) readonly buffer Input { uint8_t s_input_buffer[]; };
#define FETCH(offset) uint(s_input_buffer[offset])
#elif defined(TEXEL_BUFFER_FORMAT_R16)
SSBO_BINDING(0) readonly buffer Input { uint16_t s_input_buffer[]; };
#define FETCH(offset) uint(s_input_buffer[offset])
#elif defined(TEXEL_BUFFER_FORMAT_RGBA8)
SSBO_BINDING(0) readonly buffer Input { u8vec4 s_input_buffer[]; };
#define FETCH(offset) uvec4(s_input_buffer[offset])
#elif defined(TEXEL_BUFFER_FORMAT_R32G32)
SSBO_BINDING(0) readonly buffer Input { uvec2 s_input_buffer[]; };
#define FETCH(offset) s_input_buffer[offset]
#else
#error No texel buffer?
#endif
#ifdef HAS_PALETTE
SSBO_BINDING(1) readonly buffer Palette { uint16_t s_palette_buffer[]; };
#define FETCH_PALETTE(offset) uint(s_palette_buffer[offset])
#endif
#else
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer;
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
#if defined(TEXEL_BUFFER_FORMAT_R8) || defined(TEXEL_BUFFER_FORMAT_R16)
#define FETCH(offset) texelFetch(s_input_buffer, int((offset) + u_src_offset)).r
#elif defined(TEXEL_BUFFER_FORMAT_RGBA8)
#define FETCH(offset) texelFetch(s_input_buffer, int((offset) + u_src_offset))
#elif defined(TEXEL_BUFFER_FORMAT_R32G32)
#define FETCH(offset) texelFetch(s_input_buffer, int((offset) + u_src_offset)).rg
#else
#error No texel buffer?
#endif
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#ifdef HAS_PALETTE
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer;
#define FETCH_PALETTE(offset) texelFetch(s_palette_buffer, int((offset) + u_palette_offset)).r
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#endif
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
#endif // defined(API_METAL)
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
IMAGE_BINDING(rgba8, 0) uniform writeonly image2DArray output_image;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#define GROUP_MEMORY_BARRIER_WITH_SYNC memoryBarrierShared(); barrier();
#define GROUP_SHARED shared
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
#define DEFINE_MAIN(lx, ly) \
layout(local_size_x = lx, local_size_y = ly) in; \
void main()
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint Swap16(uint v)
{
// Convert BE to LE.
return ((v >> 8) | (v << 8)) & 0xFFFFu;
}
uint Convert3To8(uint v)
{
// Swizzle bits: 00000123 -> 12312312
return (v << 5) | (v << 2) | (v >> 1);
}
uint Convert4To8(uint v)
{
// Swizzle bits: 00001234 -> 12341234
return (v << 4) | v;
}
uint Convert5To8(uint v)
{
// Swizzle bits: 00012345 -> 12345123
return (v << 3) | (v >> 2);
}
uint Convert6To8(uint v)
{
// Swizzle bits: 00123456 -> 12345612
return (v << 2) | (v >> 4);
}
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint GetTiledTexelOffset(uint2 block_size, uint2 coords)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 block = coords / block_size;
uint2 offset = coords % block_size;
VideoCommon: Fix OpenGL ES GPU texture decoding
2022-08-20 21:21:23 +00:00
uint buffer_pos = 0u;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
buffer_pos += block.y * u_src_row_stride;
buffer_pos += block.x * (block_size.x * block_size.y);
buffer_pos += offset.y * block_size.x;
buffer_pos += offset.x;
return buffer_pos;
}
VideoCommon: Reduce duplicates of non-palette-requiring texture decode shaders
2022-06-11 07:51:24 +00:00
#if defined(HAS_PALETTE)
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 GetPaletteColor(uint index)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
// Fetch and swap BE to LE.
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = Swap16(FETCH_PALETTE(index));
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
#if defined(PALETTE_FORMAT_IA8)
uint a = bitfieldExtract(val, 8, 8);
uint i = bitfieldExtract(val, 0, 8);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
color = uint4(i, i, i, a);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
#elif defined(PALETTE_FORMAT_RGB565)
color.x = Convert5To8(bitfieldExtract(val, 11, 5));
color.y = Convert6To8(bitfieldExtract(val, 5, 6));
color.z = Convert5To8(bitfieldExtract(val, 0, 5));
color.a = 255u;
#elif defined(PALETTE_FORMAT_RGB5A3)
if ((val & 0x8000u) != 0u)
{
color.x = Convert5To8(bitfieldExtract(val, 10, 5));
color.y = Convert5To8(bitfieldExtract(val, 5, 5));
color.z = Convert5To8(bitfieldExtract(val, 0, 5));
color.a = 255u;
}
else
{
color.a = Convert3To8(bitfieldExtract(val, 12, 3));
color.r = Convert4To8(bitfieldExtract(val, 8, 4));
color.g = Convert4To8(bitfieldExtract(val, 4, 4));
color.b = Convert4To8(bitfieldExtract(val, 0, 4));
}
#else
// Not used.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
color = uint4(0, 0, 0, 0);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
#endif
return color;
}
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 GetPaletteColorNormalized(uint index)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color = GetPaletteColor(index);
return float4(color) / 255.0;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
VideoCommon: Reduce duplicates of non-palette-requiring texture decode shaders
2022-06-11 07:51:24 +00:00
#endif // defined(HAS_PALETTE)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
)";
static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::I4,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R8_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 8x8 blocks, 4 bits per pixel
// We need to do the tiling manually here because the texel size is smaller than
// the size of the buffer elements.
uint2 block = coords.xy / 8u;
uint2 offset = coords.xy % 8u;
VideoCommon: Fix OpenGL ES GPU texture decoding
2022-08-20 21:21:23 +00:00
uint buffer_pos = 0u;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
buffer_pos += block.y * u_src_row_stride;
buffer_pos += block.x * 32u;
buffer_pos += offset.y * 4u;
buffer_pos += offset.x / 2u;
// Select high nibble for odd texels, low for even.
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = FETCH(buffer_pos);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint i;
if ((coords.x & 1u) == 0u)
i = Convert4To8((val >> 4));
else
i = Convert4To8((val & 0x0Fu));
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color = uint4(i, i, i, i);
float4 norm_color = float4(color) / 255.0;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::IA4,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R8_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 8x4 blocks, 8 bits per pixel
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = FETCH(buffer_pos);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint i = Convert4To8((val & 0x0Fu));
uint a = Convert4To8((val >> 4));
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color = uint4(i, i, i, a);
float4 norm_color = float4(color) / 255.0;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::I8,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R8_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 8x4 blocks, 8 bits per pixel
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint i = FETCH(buffer_pos);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color = uint4(i, i, i, i);
float4 norm_color = float4(color) / 255.0;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::IA8,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 4x4 blocks, 16 bits per pixel
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = FETCH(buffer_pos);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint a = (val & 0xFFu);
uint i = (val >> 8);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color = uint4(i, i, i, a);
float4 norm_color = float4(color) / 255.0;
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::RGB565,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 4x4 blocks
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = Swap16(FETCH(buffer_pos));
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
color.x = Convert5To8(bitfieldExtract(val, 11, 5));
color.y = Convert6To8(bitfieldExtract(val, 5, 6));
color.z = Convert5To8(bitfieldExtract(val, 0, 5));
color.a = 255u;
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = float4(color) / 255.0;
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::RGB5A3,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 4x4 blocks
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = Swap16(FETCH(buffer_pos));
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
if ((val & 0x8000u) != 0u)
{
color.x = Convert5To8(bitfieldExtract(val, 10, 5));
color.y = Convert5To8(bitfieldExtract(val, 5, 5));
color.z = Convert5To8(bitfieldExtract(val, 0, 5));
color.a = 255u;
}
else
{
color.a = Convert3To8(bitfieldExtract(val, 12, 3));
color.r = Convert4To8(bitfieldExtract(val, 8, 4));
color.g = Convert4To8(bitfieldExtract(val, 4, 4));
color.b = Convert4To8(bitfieldExtract(val, 0, 4));
}
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = float4(color) / 255.0;
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::RGBA8,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R16_UINT, 0, 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 4x4 blocks
// We can't use the normal calculation function, as these are packed as the AR channels
// for the entire block, then the GB channels afterwards.
uint2 block = coords.xy / 4u;
uint2 offset = coords.xy % 4u;
VideoCommon: Fix OpenGL ES GPU texture decoding
2022-08-20 21:21:23 +00:00
uint buffer_pos = 0u;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Our buffer has 16-bit elements, so the offsets here are half what they would be in bytes.
buffer_pos += block.y * u_src_row_stride;
buffer_pos += block.x * 32u;
buffer_pos += offset.y * 4u;
buffer_pos += offset.x;
// The two GB channels follow after the block's AR channels.
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val1 = FETCH(buffer_pos + 0u);
uint val2 = FETCH(buffer_pos + 16u);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
color.a = (val1 & 0xFFu);
color.r = (val1 >> 8);
color.g = (val2 & 0xFFu);
color.b = (val2 >> 8);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = float4(color) / 255.0;
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::CMPR,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R32G32_UINT, 0, 64, 1, true,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
// In the compute version of this decoder, we flatten the blocks to a one-dimension array.
// Each group is subdivided into 16, and the first thread in each group fetches the DXT data.
// All threads then calculate the possible colors for the block and write to the output image.
#define GROUP_SIZE 64u
#define BLOCK_SIZE_X 4u
#define BLOCK_SIZE_Y 4u
#define BLOCK_SIZE (BLOCK_SIZE_X * BLOCK_SIZE_Y)
#define BLOCKS_PER_GROUP (GROUP_SIZE / BLOCK_SIZE)
uint DXTBlend(uint v1, uint v2)
{
// 3/8 blend, which is close to 1/3
return ((v1 * 3u + v2 * 5u) >> 3);
}
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
GROUP_SHARED uint2 shared_temp[BLOCKS_PER_GROUP];
VideoCommon: Fix CMPR compute shader layout Looks like a copy-paste gone wrong. The compute shaders for the other formats use a group size of 8 * 8, whereas the CMPR compute shader is supposed to use a flattened 64 * 1 as I understand it.
2022-07-18 16:56:50 +00:00
DEFINE_MAIN(GROUP_SIZE, 1)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
uint local_thread_id = gl_LocalInvocationID.x;
uint block_in_group = local_thread_id / BLOCK_SIZE;
uint thread_in_block = local_thread_id % BLOCK_SIZE;
uint block_index = gl_WorkGroupID.x * BLOCKS_PER_GROUP + block_in_group;
// Annoyingly, we can't precalculate this as a uniform because the DXT block size differs
// from the block size of the overall texture (4 vs 8). We can however use a multiply and
// subtraction to avoid the modulo for calculating the block's X coordinate.
uint blocks_wide = u_src_size.x / BLOCK_SIZE_X;
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 block_coords;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
block_coords.y = block_index / blocks_wide;
block_coords.x = block_index - (block_coords.y * blocks_wide);
// Only the first thread for each block reads from the texel buffer.
if (thread_in_block == 0u)
{
// Calculate tiled block coordinates.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 tile_block_coords = block_coords / 2u;
uint2 subtile_block_coords = block_coords % 2u;
VideoCommon: Fix OpenGL ES GPU texture decoding
2022-08-20 21:21:23 +00:00
uint buffer_pos = 0u;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
buffer_pos += tile_block_coords.y * u_src_row_stride;
buffer_pos += tile_block_coords.x * 4u;
buffer_pos += subtile_block_coords.y * 2u;
buffer_pos += subtile_block_coords.x;
// Read the entire DXT block to shared memory.
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint2 raw_data = FETCH(buffer_pos);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
shared_temp[block_in_group] = raw_data;
}
// Ensure store is completed before the remaining threads in the block continue.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
GROUP_MEMORY_BARRIER_WITH_SYNC;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Unpack colors and swap BE to LE.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 raw_data = shared_temp[block_in_group];
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint swapped = ((raw_data.x & 0xFF00FF00u) >> 8) | ((raw_data.x & 0x00FF00FFu) << 8);
uint c1 = swapped & 0xFFFFu;
uint c2 = swapped >> 16;
// Expand 5/6 bit channels to 8-bits per channel.
uint blue1 = Convert5To8(bitfieldExtract(c1, 0, 5));
uint blue2 = Convert5To8(bitfieldExtract(c2, 0, 5));
uint green1 = Convert6To8(bitfieldExtract(c1, 5, 6));
uint green2 = Convert6To8(bitfieldExtract(c2, 5, 6));
uint red1 = Convert5To8(bitfieldExtract(c1, 11, 5));
uint red2 = Convert5To8(bitfieldExtract(c2, 11, 5));
// Determine the four colors the block can use.
// It's quicker to just precalculate all four colors rather than branching on the index.
// NOTE: These must be masked with 0xFF. This is done at the normalization stage below.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color0, color1, color2, color3;
color0 = uint4(red1, green1, blue1, 255u);
color1 = uint4(red2, green2, blue2, 255u);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
if (c1 > c2)
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
color2 = uint4(DXTBlend(red2, red1), DXTBlend(green2, green1), DXTBlend(blue2, blue1), 255u);
color3 = uint4(DXTBlend(red1, red2), DXTBlend(green1, green2), DXTBlend(blue1, blue2), 255u);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
else
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
color2 = uint4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 255u);
color3 = uint4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 0u);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
// Calculate the texel coordinates that we will write to.
// The divides/modulo here should be turned into a shift/binary AND.
uint local_y = thread_in_block / BLOCK_SIZE_X;
uint local_x = thread_in_block % BLOCK_SIZE_X;
uint global_x = block_coords.x * BLOCK_SIZE_X + local_x;
uint global_y = block_coords.y * BLOCK_SIZE_Y + local_y;
// Use the coordinates within the block to shift the 32-bit value containing
// all 16 indices to a single 2-bit index.
uint index = bitfieldExtract(raw_data.y, int((local_y * 8u) + (6u - local_x * 2u)), 2);
// Select the un-normalized color from the precalculated color array.
// Using a switch statement here removes the need for dynamic indexing of an array.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint4 color;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
switch (index)
{
case 0u: color = color0; break;
case 1u: color = color1; break;
case 2u: color = color2; break;
case 3u: color = color3; break;
default: color = color0; break;
}
// Normalize and write to the output image.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = float4(color & 0xFFu) / 255.0;
imageStore(output_image, int3(int2(uint2(global_x, global_y)), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::C4,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C4)),
8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 8x8 blocks, 4 bits per pixel
// We need to do the tiling manually here because the texel size is smaller than
// the size of the buffer elements.
uint2 block = coords.xy / 8u;
uint2 offset = coords.xy % 8u;
VideoCommon: Fix OpenGL ES GPU texture decoding
2022-08-20 21:21:23 +00:00
uint buffer_pos = 0u;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
buffer_pos += block.y * u_src_row_stride;
buffer_pos += block.x * 32u;
buffer_pos += offset.y * 4u;
buffer_pos += offset.x / 2u;
// Select high nibble for odd texels, low for even.
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint val = FETCH(buffer_pos);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint index = ((coords.x & 1u) == 0u) ? (val >> 4) : (val & 0x0Fu);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = GetPaletteColorNormalized(index);
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::C8,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C8)),
8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 8x4 blocks, 8 bits per pixel
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint index = FETCH(buffer_pos);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = GetPaletteColorNormalized(index);
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
)"}},
Video: Clearly separate Texture and EFB Copy formats Improve bookkeeping around formats. Hopefully make code less confusing. - Rename TlutFormat -> TLUTFormat to follow conventions. - Use enum classes to prevent using a Texture format where an EFB Copy format is expected or vice-versa. - Use common EFBCopyFormat names regardless of depth and YUV configurations.
2017-07-30 19:45:55 +00:00
{TextureFormat::C14X2,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_R16_UINT,
static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C14X2)), 8, 8, false,
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 coords = gl_GlobalInvocationID.xy;
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
// Tiled in 4x4 blocks, 16 bits per pixel
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint index = Swap16(FETCH(buffer_pos)) & 0x3FFFu;
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 norm_color = GetPaletteColorNormalized(index);
imageStore(output_image, int3(int2(coords), 0), norm_color);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
)"}},
HybridXFB: Fix lint errors
2017-09-03 02:30:34 +00:00
// We do the inverse BT.601 conversion for YCbCr to RGB
// http://www.equasys.de/colorconversion.html#YCbCr-RGBColorFormatConversion
Add notes about precision of YUV->RGB conversion factors for XFB
2022-02-23 04:42:23 +00:00
// TODO: Use more precise numbers for this conversion (although on real hardware, the XFB isn't
// in a real texture format, so does this conversion actually ever happen?)
HybridXFB: Fix lint errors
2017-09-03 02:30:34 +00:00
{TextureFormat::XFB,
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{TEXEL_BUFFER_FORMAT_RGBA8_UINT, 0, 8, 8, false,
HybridXFB: Fix lint errors
2017-09-03 02:30:34 +00:00
R"(
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
DEFINE_MAIN(8, 8)
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
{
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 uv = gl_GlobalInvocationID.xy;
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
uint buffer_pos = (uv.y * u_src_row_stride) + (uv.x / 2u);
float4 yuyv = float4(FETCH(buffer_pos));
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
TextureConversionShader: fix XFB decoding shader
2019-03-01 21:51:33 +00:00
float y = (uv.x & 1u) != 0u ? yuyv.b : yuyv.r;
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
Some more implicit uint/float conversions in the texture decode shaders
2018-01-11 19:15:40 +00:00
float yComp = 1.164 * (y - 16.0);
float uComp = yuyv.g - 128.0;
float vComp = yuyv.a - 128.0;
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 rgb = float4(yComp + (1.596 * vComp),
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
yComp - (0.813 * vComp) - (0.391 * uComp),
yComp + (2.018 * uComp),
255.0);
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 rgba_norm = rgb / 255.0;
imageStore(output_image, int3(int2(uv), 0), rgba_norm);
Video Common: Add XFB decoding via the GPU
2017-08-08 05:09:25 +00:00
}
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
)"}}};
TextureConversionShader: Consider source format of EFB for EFB2RAM Currently, we use the alpha channel from the EFB even if the current format does not include an alpha channel. Now, the alpha channel is set to 1 if the format does not have an alpha channel, as well as truncating to 5/6 bits per channel. This matches the EFB-to-texture behavior.
2017-04-04 13:53:03 +00:00
const DecodingShaderInfo* GetDecodingShaderInfo(TextureFormat format)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
TextureConversionShader: Consider source format of EFB for EFB2RAM Currently, we use the alpha channel from the EFB even if the current format does not include an alpha channel. Now, the alpha channel is set to 1 if the format does not have an alpha channel, as well as truncating to 5/6 bits per channel. This matches the EFB-to-texture behavior.
2017-04-04 13:53:03 +00:00
auto iter = s_decoding_shader_info.find(format);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
return iter != s_decoding_shader_info.end() ? &iter->second : nullptr;
}
std::pair<u32, u32> GetDispatchCount(const DecodingShaderInfo* info, u32 width, u32 height)
{
// Flatten to a single dimension?
if (info->group_flatten)
return {(width * height + (info->group_size_x - 1)) / info->group_size_x, 1};
return {(width + (info->group_size_x - 1)) / info->group_size_x,
(height + (info->group_size_y - 1)) / info->group_size_y};
}
VideoCommon: Reduce duplicates of non-palette-requiring texture decode shaders
2022-06-11 07:51:24 +00:00
std::string GenerateDecodingShader(TextureFormat format, std::optional<TLUTFormat> palette_format,
TextureConversionShader: Consider source format of EFB for EFB2RAM Currently, we use the alpha channel from the EFB even if the current format does not include an alpha channel. Now, the alpha channel is set to 1 if the format does not have an alpha channel, as well as truncating to 5/6 bits per channel. This matches the EFB-to-texture behavior.
2017-04-04 13:53:03 +00:00
APIType api_type)
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
const DecodingShaderInfo* info = GetDecodingShaderInfo(format);
if (!info)
return "";
Use std::istringstream or std::ostringstream instead of std::stringstream where possible. This removes std::iostream from the inheritance chain, which reduces overhead slightly.
2019-09-14 20:40:34 +00:00
std::ostringstream ss;
VideoCommon: Reduce duplicates of non-palette-requiring texture decode shaders
2022-06-11 07:51:24 +00:00
if (palette_format.has_value())
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
{
VideoCommon: Reduce duplicates of non-palette-requiring texture decode shaders
2022-06-11 07:51:24 +00:00
switch (*palette_format)
{
case TLUTFormat::IA8:
ss << "#define PALETTE_FORMAT_IA8 1\n";
break;
case TLUTFormat::RGB565:
ss << "#define PALETTE_FORMAT_RGB565 1\n";
break;
case TLUTFormat::RGB5A3:
ss << "#define PALETTE_FORMAT_RGB5A3 1\n";
break;
}
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
}
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
switch (info->buffer_format)
{
case TEXEL_BUFFER_FORMAT_R8_UINT:
ss << "#define TEXEL_BUFFER_FORMAT_R8 1\n";
break;
case TEXEL_BUFFER_FORMAT_R16_UINT:
ss << "#define TEXEL_BUFFER_FORMAT_R16 1\n";
break;
case TEXEL_BUFFER_FORMAT_RGBA8_UINT:
ss << "#define TEXEL_BUFFER_FORMAT_RGBA8 1\n";
break;
case TEXEL_BUFFER_FORMAT_R32G32_UINT:
ss << "#define TEXEL_BUFFER_FORMAT_R32G32 1\n";
break;
case NUM_TEXEL_BUFFER_FORMATS:
[[unlikely]] ASSERT and other ASSERT usage changes
2022-07-28 04:54:27 +00:00
ASSERT(false);
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
break;
}
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
ss << decoding_shader_header;
ss << info->shader_body;
return ss.str();
}
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
std::string GeneratePaletteConversionShader(TLUTFormat palette_format, APIType api_type)
{
Use std::istringstream or std::ostringstream instead of std::stringstream where possible. This removes std::iostream from the inheritance chain, which reduces overhead slightly.
2019-09-14 20:40:34 +00:00
std::ostringstream ss;
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
ss << R"(
int Convert3To8(int v)
{
// Swizzle bits: 00000123 -> 12312312
return (v << 5) | (v << 2) | (v >> 1);
}
int Convert4To8(int v)
{
// Swizzle bits: 00001234 -> 12341234
return (v << 4) | v;
}
int Convert5To8(int v)
{
// Swizzle bits: 00012345 -> 12345123
return (v << 3) | (v >> 2);
}
int Convert6To8(int v)
{
// Swizzle bits: 00123456 -> 12345612
return (v << 2) | (v >> 4);
})";
switch (palette_format)
{
case TLUTFormat::IA8:
ss << R"(
float4 DecodePixel(int val)
{
int i = val & 0xFF;
int a = val >> 8;
return float4(i, i, i, a) / 255.0;
})";
break;
case TLUTFormat::RGB565:
ss << R"(
float4 DecodePixel(int val)
{
int r, g, b, a;
r = Convert5To8((val >> 11) & 0x1f);
g = Convert6To8((val >> 5) & 0x3f);
b = Convert5To8((val) & 0x1f);
a = 0xFF;
return float4(r, g, b, a) / 255.0;
})";
break;
case TLUTFormat::RGB5A3:
ss << R"(
float4 DecodePixel(int val)
{
int r,g,b,a;
if ((val&0x8000) > 0)
{
r=Convert5To8((val>>10) & 0x1f);
g=Convert5To8((val>>5 ) & 0x1f);
b=Convert5To8((val ) & 0x1f);
a=0xFF;
}
else
{
a=Convert3To8((val>>12) & 0x7);
r=Convert4To8((val>>8 ) & 0xf);
g=Convert4To8((val>>4 ) & 0xf);
b=Convert4To8((val ) & 0xf);
}
return float4(r, g, b, a) / 255.0;
})";
break;
default:
VideoCommon: Migrate over to fmt Migrates off the printf-based formatting where applicable.
2020-11-14 03:33:26 +00:00
PanicAlertFmt("Unknown format");
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
break;
}
ss << "\n";
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
if (api_type == APIType::Metal)
ss << "SSBO_BINDING(0) readonly buffer Palette { uint16_t palette[]; };\n";
else
ss << "TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer samp0;\n";
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
ss << "SAMPLER_BINDING(1) uniform sampler2DArray samp1;\n";
ss << "UBO_BINDING(std140, 1) uniform PSBlock {\n";
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
ss << " float multiplier;\n";
ss << " int texel_buffer_offset;\n";
ss << "};\n";
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
{
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
ss << "VARYING_LOCATION(0) in VertexData {\n";
ss << " float3 v_tex0;\n";
ss << "};\n";
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
}
else
{
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
ss << "VARYING_LOCATION(0) in float3 v_tex0;\n";
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
}
D3D / VideoCommon: generate HLSL from SPIRV
2022-05-04 05:41:34 +00:00
ss << "FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\n";
ss << "void main() {\n";
ss << " float3 coords = v_tex0;\n";
ss << " int src = int(round(texture(samp1, coords).r * multiplier));\n";
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
if (api_type == APIType::Metal)
ss << " src = int(palette[uint(src)]);\n";
else
ss << " src = int(texelFetch(samp0, src + texel_buffer_offset).r);\n";
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
VideoBackends: Add Metal renderer
2022-06-01 09:58:13 +00:00
ss << " src = ((src << 8) | (src >> 8)) & 0xFFFF;\n";
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
ss << " ocol0 = DecodePixel(src);\n";
ss << "}\n";
return ss.str();
}
EFB2RAM: Apply copy filter as a float coefficient after sampling Using 8-bit integer math here lead to precision loss for depth copies, which broke various effects in games, e.g. lens flare in MK:DD. It's unlikely the console implements this as a floating-point multiply (fixed-point perhaps), but since we have the float round trip in our EFB2RAM shaders anyway, it's not going to make things any worse. If we do rewrite our shaders to use integer math completely, then it might be worth switching this conversion back to integers. However, the range of the values (format) should be known, or we should expand all values out to 24-bits first.
2018-05-22 02:14:48 +00:00
} // namespace TextureConversionShaderTiled