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.

1548 lines
50 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
Update license headers to GPLv2+
2015-05-17 23:08:10 +00:00
// Licensed under GPLv2+
New license header introduced for DiscIO, AudioCommon, InputCommon, VideoCommon, and Common projects.
2013-04-18 03:09:55 +00:00
// Refer to the license.txt file included.
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
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 bool IntensityConstantAdded = false;
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)
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
{
Formatting cleanup for VideoCommon. Block braces on new lines. Also killed off trailing whitespace and dangling elses. Spaced some things out to make them more readable (only in places where it looked like a bit of a clusterfuck).
2013-04-24 13:21:54 +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:
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +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:
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
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:
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +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:
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +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:
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
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:
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
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:
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
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:
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
return 2;
Add support for hybrid XFB
2017-05-29 22:02:09 +00:00
case EFBCopyFormat::XFB:
return 2;
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +00:00
default:
VideoCommon: Migrate over to fmt Migrates off the printf-based formatting where applicable.
2020-11-14 03:33:26 +00:00
PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GetEncodedSampleCount)",
static_cast<int>(format));
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +00:00
return 1;
}
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
}
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)
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
if (api_type == APIType::OpenGL || api_type == APIType::Vulkan)
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
{
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
// left, top, of source rectangle within source texture
// width of the destination rectangle, scale_factor (1 or 2)
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("UBO_BINDING(std140, 1) uniform PSBlock {{\n"
" int4 position;\n"
" float y_scale;\n"
" float gamma_rcp;\n"
" float2 clamp_tb;\n"
" float3 filter_coefficients;\n"
"}};\n");
ShaderGen: Use interface blocks when geometry shaders are supported We don't use explicit locations in OpenGL currently, so this breaks when we use alternative names in the geometry shaders.
2019-04-20 13:44:33 +00:00
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
{
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("VARYING_LOCATION(0) in VertexData {{\n"
" float3 v_tex0;\n"
"}};\n");
ShaderGen: Use interface blocks when geometry shaders are supported We don't use explicit locations in OpenGL currently, so this breaks when we use alternative names in the geometry shaders.
2019-04-20 13:44:33 +00:00
}
else
{
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("VARYING_LOCATION(0) in float3 v_tex0;\n");
ShaderGen: Use interface blocks when geometry shaders are supported We don't use explicit locations in OpenGL currently, so this breaks when we use alternative names in the geometry shaders.
2019-04-20 13:44:33 +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("SAMPLER_BINDING(0) uniform sampler2DArray samp0;\n"
"FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\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
}
else // D3D
{
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("cbuffer PSBlock : register(b0) {{\n"
" int4 position;\n"
" float y_scale;\n"
" float gamma_rcp;\n"
" float2 clamp_tb;\n"
" float3 filter_coefficients;\n"
"}};\n"
"sampler samp0 : register(s0);\n"
"Texture2DArray Tex0 : register(t0);\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
}
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +00:00
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
// D3D does not have roundEven(), only round(), which is specified "to the nearest integer".
// This differs from the roundEven() behavior, but to get consistency across drivers in OpenGL
// we need to use roundEven().
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
if (api_type == APIType::D3D)
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("#define roundEven(x) round(x)\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"
" int4 val = int4(roundEven(src * 255.0)) >> 2;\n"
" return float4(val) / 63.0;\n"
"}}\n"
"float4 RGBA8ToRGB565(float4 src)\n"
"{{\n"
" int4 val = int4(roundEven(src * 255.0));\n"
" val = int4(val.r >> 3, val.g >> 2, val.b >> 3, 1);\n"
" return float4(val) / float4(31.0, 63.0, 31.0, 1.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
}
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
{
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 auto WriteSampleOp = [api_type, &code, &params](int yoffset) {
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
if (!params.depth)
{
switch (params.efb_format)
{
Convert BPMemory to BitField and enum class Additional changes: - For TevStageCombiner's ColorCombiner and AlphaCombiner, op/comparison and scale/compare_mode have been split as there are different meanings and enums if bias is set to compare. (Shift has also been renamed to scale) - In TexMode0, min_filter has been split into min_mip and min_filter. - In TexImage1, image_type is now cache_manually_managed. - The unused bit in GenMode is now exposed. - LPSize's lineaspect is now named adjust_for_aspect_ratio.
2021-02-11 02:11:31 +00:00
case PixelFormat::RGB8_Z24:
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("RGBA8ToRGB8(");
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
break;
Convert BPMemory to BitField and enum class Additional changes: - For TevStageCombiner's ColorCombiner and AlphaCombiner, op/comparison and scale/compare_mode have been split as there are different meanings and enums if bias is set to compare. (Shift has also been renamed to scale) - In TexMode0, min_filter has been split into min_mip and min_filter. - In TexImage1, image_type is now cache_manually_managed. - The unused bit in GenMode is now exposed. - LPSize's lineaspect is now named adjust_for_aspect_ratio.
2021-02-11 02:11:31 +00:00
case PixelFormat::RGBA6_Z24:
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("RGBA8ToRGBA6(");
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
break;
Convert BPMemory to BitField and enum class Additional changes: - For TevStageCombiner's ColorCombiner and AlphaCombiner, op/comparison and scale/compare_mode have been split as there are different meanings and enums if bias is set to compare. (Shift has also been renamed to scale) - In TexMode0, min_filter has been split into min_mip and min_filter. - In TexImage1, image_type is now cache_manually_managed. - The unused bit in GenMode is now exposed. - LPSize's lineaspect is now named adjust_for_aspect_ratio.
2021-02-11 02:11:31 +00:00
case PixelFormat::RGB565_Z16:
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("RGBA8ToRGB565(");
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
break;
default:
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("(");
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
break;
}
}
else
{
// Handle D3D depth inversion.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
if (!g_ActiveConfig.backend_info.bSupportsReversedDepthRange)
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("1.0 - (");
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
else
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("(");
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
}
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +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
if (api_type == APIType::OpenGL || api_type == APIType::Vulkan)
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("texture(samp0, float3(");
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
else
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("Tex0.Sample(samp0, float3(");
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("uv.x + float(xoffset) * pixel_size.x, ");
VideoCommon: Add APIType entry for Vulkan
2016-08-12 14:55:00 +00:00
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
// Reverse the direction for OpenGL, since positive numbers are distance from the bottom row.
if (yoffset != 0)
{
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
if (api_type == APIType::OpenGL)
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("clamp(uv.y - float({}) * pixel_size.y, clamp_tb.x, clamp_tb.y)", yoffset);
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
else
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("clamp(uv.y + float({}) * pixel_size.y, clamp_tb.x, clamp_tb.y)", yoffset);
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
}
else
{
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("uv.y");
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
}
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(", 0.0)))");
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.
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 SampleEFB(float2 uv, float2 pixel_size, int xoffset)\n"
"{{\n");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
if (params.copy_filter)
{
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 prev_row = ");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
WriteSampleOp(-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(";\n"
" float4 current_row = ");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
WriteSampleOp(0);
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"
" float4 next_row = ");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
WriteSampleOp(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(";\n"
" return float4(min(prev_row.rgb * filter_coefficients[0] +\n"
" current_row.rgb * filter_coefficients[1] +\n"
" next_row.rgb * filter_coefficients[2], \n"
" float3(1, 1, 1)), current_row.a);\n");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
}
else
{
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 current_row = ");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +00:00
WriteSampleOp(0);
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"
"return float4(min(current_row.rgb * filter_coefficients[1], float3(1, 1, 1)),\n"
" current_row.a);\n");
TextureConversionShader: Don't sample from adjacent rows when not needed
2018-05-03 04:09:32 +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");
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
static void WriteSwizzler(ShaderCode& code, const EFBCopyParams& params, EFBCopyFormat format,
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
{
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
WriteHeader(code, api_type);
WriteSampleFunction(code, params, 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
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
if (api_type == APIType::OpenGL || api_type == APIType::Vulkan)
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
{
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("void main()\n"
"{{\n"
" int2 sampleUv;\n"
" int2 uv1 = int2(gl_FragCoord.xy);\n");
VideoCommon: Add APIType entry for Vulkan
2016-08-12 14:55:00 +00:00
}
Shader generators: Remove any references to D3D9 and cleanup the affected code.
2013-09-22 16:07:21 +00:00
else // D3D
hopefully fixed zww issue with new efb to ram. implemented new efb to ram in opengl modified TextureConversionShader preparing the implementation of new efb to ram in dx11 please test for regressions git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5874 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-07-12 19:30:25 +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("void main(\n"
" in float3 v_tex0 : TEXCOORD0,\n"
" in float4 rawpos : SV_Position,\n"
" out float4 ocol0 : SV_Target)\n"
"{{\n"
" int2 sampleUv;\n"
" int2 uv1 = int2(rawpos.xy);\n");
hopefully fixed zww issue with new efb to ram. implemented new efb to ram in opengl modified TextureConversionShader preparing the implementation of new efb to ram in dx11 please test for regressions git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5874 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-07-12 19:30:25 +00:00
}
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +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
const int blkW = TexDecoder_GetEFBCopyBlockWidthInTexels(format);
const int blkH = TexDecoder_GetEFBCopyBlockHeightInTexels(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
int samples = GetEncodedSampleCount(format);
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_block_position = (uv1.x >> {}) << {};\n", IntLog2(blkH * blkW / samples),
IntLog2(blkW));
code.Write(" int y_block_position = uv1.y << {};\n", 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);
code.Write(" int y_offset_in_block = offset_in_block >> {};\n", IntLog2(blkW / samples));
code.Write(" int x_offset_in_block = (offset_in_block & {}) << {};\n", (blkW / samples) - 1,
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)
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(" {} = SampleEFB(uv0, pixel_size, {}).{};\n", dest, x_offset, color_comp);
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 WriteColorToIntensity(ShaderCode& code, std::string_view src, std::string_view dest)
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
{
fix formatting uglies introduced in glsl-master branch
2011-12-26 05:15:54 +00:00
if (!IntensityConstantAdded)
small code clean up: d3d: remove the depth texture path it will not work so for now only lockable textures were available. i thing the only way will be a use a secondary render target and do a depth pass to mimic depth textures. opengl: minor cleanup here and there and a possible fix to issue 1509, but not tested because in my system the errors remarked in the issue don't show. commond: code reorganization an optimization in the pixel shader generator, trying to understand the tev stages, make some changes to make the generator faster (not much only started for the alpha test and fog). this changes try start solving the diferences bethen the hardware plugins and the soft plugin. i hope with i don't brake nothing but please test this a lot. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4465 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-10-25 02:35:21 +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 IntensityConst = float4(0.257f,0.504f,0.098f,0.0625f);\n");
small code clean up: d3d: remove the depth texture path it will not work so for now only lockable textures were available. i thing the only way will be a use a secondary render target and do a depth pass to mimic depth textures. opengl: minor cleanup here and there and a possible fix to issue 1509, but not tested because in my system the errors remarked in the issue don't show. commond: code reorganization an optimization in the pixel shader generator, trying to understand the tev stages, make some changes to make the generator faster (not much only started for the alpha test and fog). this changes try start solving the diferences bethen the hardware plugins and the soft plugin. i hope with i don't brake nothing but please test this a lot. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4465 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-10-25 02:35:21 +00:00
IntensityConstantAdded = true;
}
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(" {} = dot(IntensityConst.rgb, {}.rgb);\n", dest, src);
made texture conversion shaders use less instructions this is mainly so they fit within ps_2_0 limits, but I made this separate from my last checkin to make it easier to test separately in case it somehow causes problems git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6619 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-12-19 21:05:41 +00:00
// don't add IntensityConst.a yet, because doing it later is faster and uses less instructions,
// due to vectorization
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)
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(" {} = floor({} * 255.0 / exp2(8.0 - {}.0));\n", dest, src, depth);
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 WriteEncoderEnd(ShaderCode& code)
small code clean up: d3d: remove the depth texture path it will not work so for now only lockable textures were available. i thing the only way will be a use a secondary render target and do a depth pass to mimic depth textures. opengl: minor cleanup here and there and a possible fix to issue 1509, but not tested because in my system the errors remarked in the issue don't show. commond: code reorganization an optimization in the pixel shader generator, trying to understand the tev stages, make some changes to make the generator faster (not much only started for the alpha test and fog). this changes try start solving the diferences bethen the hardware plugins and the soft plugin. i hope with i don't brake nothing but please test this a lot. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4465 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-10-25 02:35:21 +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");
small code clean up: d3d: remove the depth texture path it will not work so for now only lockable textures were available. i thing the only way will be a use a secondary render target and do a depth pass to mimic depth textures. opengl: minor cleanup here and there and a possible fix to issue 1509, but not tested because in my system the errors remarked in the issue don't show. commond: code reorganization an optimization in the pixel shader generator, trying to understand the tev stages, make some changes to make the generator faster (not much only started for the alpha test and fog). this changes try start solving the diferences bethen the hardware plugins and the soft plugin. i hope with i don't brake nothing but please test this a lot. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4465 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-10-25 02:35:21 +00:00
IntensityConstantAdded = false;
}
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 WriteI8Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
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
WriteSwizzler(code, params, EFBCopyFormat::R8, api_type);
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 texSample;\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, "rgb", "texSample", 0, api_type, params);
WriteColorToIntensity(code, "texSample", "ocol0.b");
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, "rgb", "texSample", 1, api_type, params);
WriteColorToIntensity(code, "texSample", "ocol0.g");
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, "rgb", "texSample", 2, api_type, params);
WriteColorToIntensity(code, "texSample", "ocol0.r");
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, "rgb", "texSample", 3, api_type, params);
WriteColorToIntensity(code, "texSample", "ocol0.a");
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
// See WriteColorToIntensity
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.rgba += IntensityConst.aaaa;\n");
made texture conversion shaders use less instructions this is mainly so they fit within ps_2_0 limits, but I made this separate from my last checkin to make it easier to test separately in case it somehow causes problems git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6619 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-12-19 21:05:41 +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
WriteEncoderEnd(code);
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 WriteI4Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
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
WriteSwizzler(code, params, EFBCopyFormat::R4, api_type);
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 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, "rgb", "texSample", 0, api_type, params);
WriteColorToIntensity(code, "texSample", "color0.b");
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, "rgb", "texSample", 1, api_type, params);
WriteColorToIntensity(code, "texSample", "color1.b");
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, "rgb", "texSample", 2, api_type, params);
WriteColorToIntensity(code, "texSample", "color0.g");
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, "rgb", "texSample", 3, api_type, params);
WriteColorToIntensity(code, "texSample", "color1.g");
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, "rgb", "texSample", 4, api_type, params);
WriteColorToIntensity(code, "texSample", "color0.r");
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, "rgb", "texSample", 5, api_type, params);
WriteColorToIntensity(code, "texSample", "color1.r");
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, "rgb", "texSample", 6, api_type, params);
WriteColorToIntensity(code, "texSample", "color0.a");
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, "rgb", "texSample", 7, api_type, params);
WriteColorToIntensity(code, "texSample", "color1.a");
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(" color0.rgba += IntensityConst.aaaa;\n"
" color1.rgba += IntensityConst.aaaa;\n");
made texture conversion shaders use less instructions this is mainly so they fit within ps_2_0 limits, but I made this separate from my last checkin to make it easier to test separately in case it somehow causes problems git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6619 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-12-19 21:05:41 +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");
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
WriteEncoderEnd(code);
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 WriteIA8Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
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
WriteSwizzler(code, params, EFBCopyFormat::RA8, api_type);
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");
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(" ocol0.b = texSample.a;\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
WriteColorToIntensity(code, "texSample", "ocol0.g");
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(" ocol0.r = texSample.a;\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
WriteColorToIntensity(code, "texSample", "ocol0.a");
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.ga += IntensityConst.aa;\n");
made texture conversion shaders use less instructions this is mainly so they fit within ps_2_0 limits, but I made this separate from my last checkin to make it easier to test separately in case it somehow causes problems git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6619 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-12-19 21:05:41 +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
WriteEncoderEnd(code);
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 WriteIA4Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& params)
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
WriteSwizzler(code, params, EFBCopyFormat::RA4, api_type);
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");
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
WriteColorToIntensity(code, "texSample", "color1.b");
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.g = texSample.a;\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
WriteColorToIntensity(code, "texSample", "color1.g");
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", 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.a;\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
WriteColorToIntensity(code, "texSample", "color1.r");
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", 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.a;\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
WriteColorToIntensity(code, "texSample", "color1.a");
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(" color1.rgba += IntensityConst.aaaa;\n");
made texture conversion shaders use less instructions this is mainly so they fit within ps_2_0 limits, but I made this separate from my last checkin to make it easier to test separately in case it somehow causes problems git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6619 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-12-19 21:05:41 +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");
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
WriteEncoderEnd(code);
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)
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
WriteSwizzler(code, params, EFBCopyFormat::RGB565, api_type);
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");
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
WriteEncoderEnd(code);
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
{
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
WriteSwizzler(code, params, EFBCopyFormat::RGB5A3, api_type);
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");
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
WriteEncoderEnd(code);
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)
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
WriteSwizzler(code, params, EFBCopyFormat::RGBA8, api_type);
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(" 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");
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
WriteEncoderEnd(code);
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)
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
WriteSwizzler(code, params, EFBCopyFormat::R4, api_type);
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");
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
WriteEncoderEnd(code);
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)
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
WriteSwizzler(code, params, EFBCopyFormat::R8, api_type);
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, "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);
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
WriteEncoderEnd(code);
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)
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
WriteSwizzler(code, params, EFBCopyFormat::RA4, api_type);
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");
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
WriteEncoderEnd(code);
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)
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
WriteSwizzler(code, params, EFBCopyFormat::RA8, api_type);
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, "ocol0.bg", 0, api_type, params);
WriteSampleColor(code, comp, "ocol0.ra", 1, api_type, params);
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
WriteEncoderEnd(code);
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 WriteZ8Encoder(ShaderCode& code, std::string_view multiplier, 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)
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
WriteSwizzler(code, params, EFBCopyFormat::G8, api_type);
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
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(" float depth;\n");
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
WriteSampleColor(code, "r", "depth", 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("ocol0.b = frac(depth * {});\n", multiplier);
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
WriteSampleColor(code, "r", "depth", 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("ocol0.g = frac(depth * {});\n", multiplier);
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
WriteSampleColor(code, "r", "depth", 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("ocol0.r = frac(depth * {});\n", multiplier);
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
WriteSampleColor(code, "r", "depth", 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("ocol0.a = frac(depth * {});\n", multiplier);
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
WriteEncoderEnd(code);
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 WriteZ16Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& 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
WriteSwizzler(code, params, EFBCopyFormat::RA8, api_type);
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
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(" float depth;\n"
" float3 expanded;\n");
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
// Byte order is reversed
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
WriteSampleColor(code, "r", "depth", 0, api_type, params);
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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(" depth *= 16777216.0;\n"
" expanded.r = floor(depth / (256.0 * 256.0));\n"
" depth -= expanded.r * 256.0 * 256.0;\n"
" expanded.g = floor(depth / 256.0);\n");
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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.b = expanded.g / 255.0;\n"
" ocol0.g = expanded.r / 255.0;\n");
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
WriteSampleColor(code, "r", "depth", 1, api_type, params);
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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(" depth *= 16777216.0;\n"
" expanded.r = floor(depth / (256.0 * 256.0));\n"
" depth -= expanded.r * 256.0 * 256.0;\n"
" expanded.g = floor(depth / 256.0);\n");
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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.r = expanded.g / 255.0;\n"
" ocol0.a = expanded.r / 255.0;\n");
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
WriteEncoderEnd(code);
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 WriteZ16LEncoder(ShaderCode& code, APIType api_type, const EFBCopyParams& 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
WriteSwizzler(code, params, EFBCopyFormat::GB8, api_type);
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
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(" float depth;\n"
" float3 expanded;\n");
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
// Byte order is reversed
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
WriteSampleColor(code, "r", "depth", 0, api_type, params);
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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(" depth *= 16777216.0;\n"
" expanded.r = floor(depth / (256.0 * 256.0));\n"
" depth -= expanded.r * 256.0 * 256.0;\n"
" expanded.g = floor(depth / 256.0);\n"
" depth -= expanded.g * 256.0;\n"
" expanded.b = depth;\n");
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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.b = expanded.b / 255.0;\n"
" ocol0.g = expanded.g / 255.0;\n");
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
WriteSampleColor(code, "r", "depth", 1, api_type, params);
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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(" depth *= 16777216.0;\n"
" expanded.r = floor(depth / (256.0 * 256.0));\n"
" depth -= expanded.r * 256.0 * 256.0;\n"
" expanded.g = floor(depth / 256.0);\n"
" depth -= expanded.g * 256.0;\n"
" expanded.b = depth;\n");
Fixed 24 bit depth copies to RAM. 24 and 16 bit depth copies are now more accurate. Added an offset to DX copies to RAM and made half sized copies to a texture linearly filtered. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4635 8ced0084-cf51-0410-be5f-012b33b47a6e
2009-12-02 04:17:18 +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.r = expanded.b / 255.0;\n"
" ocol0.a = expanded.g / 255.0;\n");
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
WriteEncoderEnd(code);
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 WriteZ24Encoder(ShaderCode& code, APIType api_type, const EFBCopyParams& 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
WriteSwizzler(code, params, EFBCopyFormat::RGBA8, api_type);
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(" float depth0;\n"
" float depth1;\n"
" float3 expanded0;\n"
" float3 expanded1;\n");
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +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, "r", "depth0", 0, api_type, params);
WriteSampleColor(code, "r", "depth1", 1, api_type, params);
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +00:00
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +00:00
for (int i = 0; i < 2; i++)
{
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(" depth{} *= 16777216.0;\n", i);
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(" expanded{}.r = floor(depth{} / (256.0 * 256.0));\n", i, i);
code.Write(" depth{} -= expanded{}.r * 256.0 * 256.0;\n", i, i);
code.Write(" expanded{}.g = floor(depth{} / 256.0);\n", i, i);
code.Write(" depth{} -= expanded{}.g * 256.0;\n", i, i);
code.Write(" expanded{}.b = depth{};\n", i, i);
Clean up more space/tab mismatches in AudioCommon, Common, and VideoCommon. Not planning to touch Core since it's the most actively changed part of the project.
2013-03-20 01:51:12 +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(" if (!first) {{\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
// Upper 16
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 = expanded0.g / 255.0;\n"
" ocol0.g = expanded0.b / 255.0;\n"
" ocol0.r = expanded1.g / 255.0;\n"
" ocol0.a = expanded1.b / 255.0;\n"
" }} else {{\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
// Lower 8
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 = 1.0;\n"
" ocol0.g = expanded0.r / 255.0;\n"
" ocol0.r = 1.0;\n"
" ocol0.a = expanded1.r / 255.0;\n"
" }}\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
WriteEncoderEnd(code);
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
{
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
WriteSwizzler(code, params, EFBCopyFormat::XFB, api_type);
HybridXFB: Fix lint errors
2017-09-03 02:30:34 +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 color0, 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, "rgb", "color0", 0, api_type, params);
WriteSampleColor(code, "rgb", "color1", 1, api_type, params);
HybridXFB: Fix lint errors
2017-09-03 02:30:34 +00:00
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
// Gamma is only applied to XFB copies.
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 = pow(color0, float3(gamma_rcp, gamma_rcp, gamma_rcp));\n"
" color1 = pow(color1, float3(gamma_rcp, gamma_rcp, gamma_rcp));\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
// Convert to YUV.
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(" const float3 y_const = float3(0.257, 0.504, 0.098);\n"
" const float3 u_const = float3(-0.148, -0.291, 0.439);\n"
" const float3 v_const = float3(0.439, -0.368, -0.071);\n"
" float3 average = (color0 + color1) * 0.5;\n"
" ocol0.b = dot(color0, y_const) + 0.0625;\n"
" ocol0.g = dot(average, u_const) + 0.5;\n"
" ocol0.r = dot(color1, y_const) + 0.0625;\n"
" ocol0.a = dot(average, v_const) + 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
WriteEncoderEnd(code);
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)
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
ShaderCode code;
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +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
switch (params.copy_format)
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
{
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:
if (params.yuv)
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
WriteI4Encoder(code, api_type, params);
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
else
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
WriteC4Encoder(code, "r", api_type, params);
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
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:
if (params.yuv)
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
WriteIA4Encoder(code, api_type, params);
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
else
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
WriteCC4Encoder(code, "ar", api_type, params);
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
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:
if (params.yuv)
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
WriteIA8Encoder(code, api_type, params);
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
else
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
WriteCC8Encoder(code, "ar", api_type, params);
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
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);
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
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);
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
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:
if (params.depth)
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
WriteZ24Encoder(code, api_type, params);
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
else
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
WriteRGBA8Encoder(code, api_type, params);
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
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);
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
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:
if (params.yuv)
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
WriteI8Encoder(code, api_type, params);
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
else
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, "r", api_type, params);
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
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:
if (params.depth)
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
WriteZ8Encoder(code, "256.0", api_type, params); // Z8M
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
else
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, "g", api_type, params);
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
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:
if (params.depth)
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
WriteZ8Encoder(code, "65536.0", api_type, params); // Z8L
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
else
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, "b", api_type, params);
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
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:
if (params.depth)
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
WriteZ16Encoder(code, api_type, params); // Z16H
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
else
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
WriteCC8Encoder(code, "gr", api_type, params);
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
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:
if (params.depth)
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
WriteZ16LEncoder(code, api_type, params); // Z16L
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
else
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
WriteCC8Encoder(code, "bg", api_type, params);
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
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:
VideoCommon: Migrate over to fmt Migrates off the printf-based formatting where applicable.
2020-11-14 03:33:26 +00:00
PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GenerateEncodingShader)",
static_cast<int>(params.copy_format));
Shader generators: Remove any references to D3D9 and cleanup the affected code.
2013-09-22 16:07:21 +00:00
break;
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
}
Reformat all the things. Have fun with merge conflicts.
2016-06-24 08:43:46 +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
return code.GetBuffer();
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
#ifdef API_D3D
cbuffer UBO : register(b0) {
#else
UBO_BINDING(std140, 1) uniform UBO {
#endif
uint2 u_dst_size;
uint2 u_src_size;
uint u_src_offset;
uint u_src_row_stride;
uint u_palette_offset;
};
#ifdef API_D3D
Buffer<uint4> s_input_buffer : register(t0);
#ifdef HAS_PALETTE
Buffer<uint4> s_palette_buffer : register(t1);
#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
RWTexture2DArray<unorm float4> output_image : register(u0);
// Helpers for reading/writing.
#define texelFetch(buffer, pos) buffer.Load(pos)
#define imageStore(image, coords, value) image[coords] = value
#define GROUP_MEMORY_BARRIER_WITH_SYNC GroupMemoryBarrierWithGroupSync();
#define GROUP_SHARED groupshared
#define DEFINE_MAIN(lx, ly) \
[numthreads(lx, ly, 1)] \
void main(uint3 gl_WorkGroupID : SV_GroupId, \
uint3 gl_LocalInvocationID : SV_GroupThreadID, \
uint3 gl_GlobalInvocationID : SV_DispatchThreadID)
uint bitfieldExtract(uint val, int off, int size)
{
// This built-in function is only support in OpenGL 4.0+ and ES 3.1+\n"
// Microsoft's HLSL compiler automatically optimises this to a bitfield extract instruction.
uint mask = uint((1 << size) - 1);
return uint(val >> off) & mask;
}
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
TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer;
#ifdef HAS_PALETTE
TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer;
#endif
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
#endif
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: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint buffer_pos = u_src_offset;
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;
}
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.
uint val = Swap16(texelFetch(s_palette_buffer, int(u_palette_offset + index)).x);
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
}
)";
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;
uint buffer_pos = u_src_offset;
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.
uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
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);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
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);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint i = texelFetch(s_input_buffer, int(buffer_pos)).x;
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);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
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);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x);
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);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x);
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;
uint buffer_pos = u_src_offset;
// 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.
uint val1 = texelFetch(s_input_buffer, int(buffer_pos + 0u)).x;
uint val2 = texelFetch(s_input_buffer, int(buffer_pos + 16u)).x;
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];
DEFINE_MAIN(GROUP_SIZE, 8)
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: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint buffer_pos = u_src_offset;
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.
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
uint2 raw_data = texelFetch(s_input_buffer, int(buffer_pos)).xy;
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;
uint buffer_pos = u_src_offset;
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.
uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
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);
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
uint index = texelFetch(s_input_buffer, int(buffer_pos)).x;
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);
TextureConversionShader: Add missing swap for index of C14X2 textures
2017-04-06 13:29:40 +00:00
uint index = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x) & 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
{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;
GLSL-ES doesn't allow implicit int/uint conversions
2018-01-11 18:20:14 +00:00
int buffer_pos = int(u_src_offset + (uv.y * u_src_row_stride) + (uv.x / 2u));
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +00:00
float4 yuyv = float4(texelFetch(s_input_buffer, 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};
}
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
std::string GenerateDecodingShader(TextureFormat format, 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: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
switch (palette_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 TLUTFormat::IA8:
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
ss << "#define PALETTE_FORMAT_IA8 1\n";
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 TLUTFormat::RGB565:
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
ss << "#define PALETTE_FORMAT_RGB565 1\n";
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 TLUTFormat::RGB5A3:
VideoCommon: Add texture decoding shader generators
2016-11-27 08:14:58 +00:00
ss << "#define PALETTE_FORMAT_RGB5A3 1\n";
break;
}
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";
if (api_type == APIType::D3D)
{
ss << "Buffer<uint> tex0 : register(t0);\n";
ss << "Texture2DArray tex1 : register(t1);\n";
ss << "SamplerState samp1 : register(s1);\n";
ss << "cbuffer PSBlock : register(b0) {\n";
}
else
{
ss << "TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer samp0;\n";
ss << "SAMPLER_BINDING(1) uniform sampler2DArray samp1;\n";
ss << "UBO_BINDING(std140, 1) uniform PSBlock {\n";
}
ss << " float multiplier;\n";
ss << " int texel_buffer_offset;\n";
ss << "};\n";
if (api_type == APIType::D3D)
{
ss << "void main(in float3 v_tex0 : TEXCOORD0, out float4 ocol0 : SV_Target) {\n";
ss << " int src = int(round(tex1.Sample(samp1, v_tex0).r * multiplier));\n";
ss << " src = int(tex0.Load(src + texel_buffer_offset).r);\n";
}
else
{
ShaderGen: Use interface blocks when geometry shaders are supported We don't use explicit locations in OpenGL currently, so this breaks when we use alternative names in the geometry shaders.
2019-04-20 13:44:33 +00:00
if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
{
ss << "VARYING_LOCATION(0) in VertexData {\n";
ss << " float3 v_tex0;\n";
ss << "};\n";
}
else
{
ss << "VARYING_LOCATION(0) in float3 v_tex0;\n";
}
Move most backend functionality to VideoCommon
2019-02-15 01:59:50 +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";
ss << " src = int(texelFetch(samp0, src + texel_buffer_offset).r);\n";
}
ss << " src = ((src << 8) & 0xFF00) | (src >> 8);\n";
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