mirror of
https://github.com/cemu-project/cemu_graphic_packs.git
synced 2024-11-22 17:49:17 +01:00
549758507f
But now done properly! Basically, a bunch of improvements were made to the script. The previous attempt at this conversion was quickly followed by a rollback since I realized that the script was overlooking certain things that made most of the packs hit or miss whether they would work. A few things missing were: - It only tested the values from 1 preset. Now, each shader gets compiled per each preset, like what Cemu would do. It also merges the changes done for each preset into one. This should solve cases where one shader would define things separately or repeatedly from preset to preset. - All* of the shaders are tested to see if they use the converter used the right values for the locations for Vulkan. Both of these *should* mean that they should both compile and be linkable in Vulkan, which means that I don't have to test each individual shader to see if they work. I will release the two scripts (one used for converting, one used for checking the right values for the locations) tomorrow so that other people might be able to help, if they want. It's fairly straightforward now at least. * Organize workaround graphic packs Pretty hard to organize these correctly, but according to our discord discussion, this was the best layout from a bunch I proposed, together with some suggestions. * Add V4 converter script and instructions on how to use it Now everyone BotW is done and all of the bugs have been kinked out using it (hopefully...), here's the release of the converter script in all of it's very badly coded glory. I hope I didn't leave too much debug glory in there... Also, I hope that I didn't make too many grammatical mistakes in the instructions, but hopefully it's easy enough to follow.
183 lines
6.4 KiB
Plaintext
183 lines
6.4 KiB
Plaintext
#version 420
|
|
#extension GL_ARB_texture_gather : enable
|
|
#extension GL_ARB_separate_shader_objects : enable
|
|
#ifdef VULKAN
|
|
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
|
|
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
|
|
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
|
|
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
|
|
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
|
|
#define gl_VertexID gl_VertexIndex
|
|
#define gl_InstanceID gl_InstanceIndex
|
|
#else
|
|
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
|
|
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
|
|
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
|
|
#define SET_POSITION(_v) gl_Position = _v
|
|
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
|
|
#endif
|
|
// This shaders was auto-converted from OpenGL to Cemu.
|
|
|
|
|
|
// shader f14bb57cd5c9cb77 - dumped 1.15
|
|
// Used for: Removing/Restoring the native BotW World Anti-Aliasing implementation
|
|
|
|
const float resX = float($width)/float($gameWidth);
|
|
const float resY = float($height)/float($gameHeight);
|
|
|
|
#ifdef VULKAN
|
|
layout(set = 1, binding = 2) uniform ufBlock
|
|
{
|
|
uniform ivec4 uf_remappedPS[4];
|
|
uniform vec4 uf_fragCoordScale;
|
|
};
|
|
#else
|
|
uniform ivec4 uf_remappedPS[4];
|
|
uniform vec2 uf_fragCoordScale;
|
|
#endif
|
|
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
|
|
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
|
|
layout(location = 0) in vec4 passParameterSem2;
|
|
layout(location = 0) out vec4 passPixelColor0;
|
|
// uf_fragCoordScale was moved to the ufBlock
|
|
|
|
int clampFI32(int v)
|
|
{
|
|
if( v == 0x7FFFFFFF )
|
|
return floatBitsToInt(1.0);
|
|
else if( v == 0xFFFFFFFF )
|
|
return floatBitsToInt(0.0);
|
|
return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
|
|
}
|
|
float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));}
|
|
void main()
|
|
{
|
|
vec4 R0f = vec4(0.0);
|
|
vec4 R1f = vec4(0.0); // Important variable
|
|
vec4 R2f = vec4(0.0);
|
|
vec4 R3f = vec4(0.0); // Important variable
|
|
vec4 R123f = vec4(0.0);
|
|
vec4 R126f = vec4(0.0);
|
|
vec4 R127f = vec4(0.0);
|
|
float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
|
|
vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
|
|
float PS0f = 0.0, PS1f = 0.0;
|
|
vec4 tempf = vec4(0.0);
|
|
float tempResultf;
|
|
int tempResulti;
|
|
ivec4 ARi = ivec4(0);
|
|
bool predResult = true;
|
|
bool activeMaskStack[2];
|
|
bool activeMaskStackC[3];
|
|
activeMaskStack[0] = false;
|
|
activeMaskStackC[0] = false;
|
|
activeMaskStackC[1] = false;
|
|
activeMaskStack[0] = true;
|
|
activeMaskStackC[0] = true;
|
|
activeMaskStackC[1] = true;
|
|
vec3 cubeMapSTM;
|
|
int cubeMapFaceId;
|
|
R0f = passParameterSem2;
|
|
if( activeMaskStackC[1] == true ) {
|
|
R1f.xyzw = (textureGather(textureUnitPS1, R0f.xy).wzxy);
|
|
R2f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
|
|
}
|
|
if( activeMaskStackC[1] == true ) {
|
|
activeMaskStack[1] = activeMaskStack[0];
|
|
activeMaskStackC[2] = activeMaskStackC[1];
|
|
// 0
|
|
PV0f.x = R1f.w + -(R1f.x);
|
|
PV0f.y = R1f.z + -(R1f.y);
|
|
PV0f.z = mul_nonIEEE(R2f.x, intBitsToFloat(uf_remappedPS[0].x));
|
|
R127f.w = min(R1f.z, R1f.x);
|
|
R127f.x = min(R1f.w, R1f.y);
|
|
PS0f = R127f.x;
|
|
// 1
|
|
R123f.x = (mul_nonIEEE(R2f.y,intBitsToFloat(uf_remappedPS[0].y) * resX ) + PV0f.z); //Important line
|
|
PV1f.x = R123f.x;
|
|
PV1f.y = max(R1f.z, R1f.x);
|
|
R127f.z = PV0f.y + -(PV0f.x);
|
|
PV1f.z = R127f.z;
|
|
R126f.w = PV0f.y + PV0f.x;
|
|
PV1f.w = R126f.w;
|
|
PS1f = max(R1f.w, R1f.y);
|
|
// 2
|
|
PV0f.x = max(PV1f.z, -(PV1f.z));
|
|
PV0f.y = max(PV1f.w, -(PV1f.w));
|
|
R123f.z = (mul_nonIEEE(R2f.z,intBitsToFloat(uf_remappedPS[0].z)) + PV1f.x);
|
|
PV0f.z = R123f.z;
|
|
PV0f.w = min(R127f.w, R127f.x);
|
|
PS0f = max(PV1f.y, PS1f);
|
|
// 3
|
|
PV1f.x = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].x));
|
|
PV1f.y = max(PV0f.z, PS0f);
|
|
PV1f.z = min(PV0f.z, PV0f.w);
|
|
PV1f.w = min(PV0f.y, PV0f.x);
|
|
// 4
|
|
R1f.x = -(PV1f.z) + PV1f.y;
|
|
R0f.z = max(PV1f.x, intBitsToFloat(uf_remappedPS[1].y)); // Important - Divide looks blurrier/fuzzy and multiply looks sharper good
|
|
PS0f = 1.0 / PV1f.w; // Important line affects aliasing strongly, increasing it is blurier and decreasing sharpens
|
|
// 5
|
|
PV1f.x = mul_nonIEEE(R127f.z, PS0f);
|
|
PV1f.y = mul_nonIEEE(R126f.w, PS0f);
|
|
// 6
|
|
PV0f.z = max(PV1f.x, -(intBitsToFloat(uf_remappedPS[2].y)));
|
|
PV0f.w = max(PV1f.y, -(intBitsToFloat(uf_remappedPS[2].y)));
|
|
// 7 - another way to do it other than the original implmentation
|
|
R3f.x = min(PV0f.w, intBitsToFloat(uf_remappedPS[2].y)); // Important - Divide looks sharper and better and multiply looks blurier fuzzy
|
|
R1f.y = min(PV0f.z, intBitsToFloat(uf_remappedPS[2].y)); // Important - Divide looks sharper and better and multiply looks blurier fuzzy
|
|
// 8
|
|
predResult = (R1f.x > R0f.z);
|
|
activeMaskStack[1] = predResult;
|
|
activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true;
|
|
}
|
|
else {
|
|
activeMaskStack[1] = false;
|
|
activeMaskStackC[2] = false;
|
|
}
|
|
if( activeMaskStackC[2] == true ) {
|
|
// 0
|
|
backupReg0f = R3f.x;
|
|
backupReg0f = R3f.x;
|
|
R3f.x = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[3].x) / resX) + R0f.x); // Original Implementation
|
|
R3f.y = (mul_nonIEEE(R1f.y,intBitsToFloat(uf_remappedPS[3].y) / resY) + R0f.y); // Original Implementation
|
|
R1f.x = (mul_nonIEEE(backupReg0f,-(intBitsToFloat(uf_remappedPS[3].x) / resX)) + R0f.x); // Original Implementation
|
|
PS0f = R1f.x;
|
|
// 1
|
|
backupReg0f = R1f.y;
|
|
R1f.y = (mul_nonIEEE(backupReg0f,-(intBitsToFloat(uf_remappedPS[3].y) / resY)) + R0f.y); // Original Implementation
|
|
}
|
|
if( activeMaskStackC[2] == true ) {
|
|
R0f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
|
|
R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
|
|
}
|
|
if( activeMaskStackC[2] == true ) {
|
|
// 0
|
|
R127f.x = R0f.w + R1f.w;
|
|
R127f.x /= 2.0;
|
|
PV0f.x = R127f.x;
|
|
R127f.y = R0f.z + R1f.z;
|
|
R127f.y /= 2.0;
|
|
PV0f.y = R127f.y;
|
|
R127f.z = R0f.y + R1f.y;
|
|
R127f.z /= 2.0;
|
|
PV0f.z = R127f.z;
|
|
R127f.w = R0f.x + R1f.x;
|
|
R127f.w /= 2.0;
|
|
PV0f.w = R127f.w;
|
|
// 1
|
|
PV1f.x = R2f.w + -(PV0f.x);
|
|
PV1f.y = R2f.z + -(PV0f.y);
|
|
PV1f.z = R2f.y + -(PV0f.z);
|
|
PV1f.w = R2f.x + -(PV0f.w);
|
|
// 2
|
|
R2f.x = (PV1f.w * intBitsToFloat(0x3eb33333) + R127f.w);
|
|
R2f.y = (PV1f.z * intBitsToFloat(0x3eb33333) + R127f.z);
|
|
R2f.z = (PV1f.y * intBitsToFloat(0x3eb33333) + R127f.y);
|
|
R2f.w = (PV1f.x * intBitsToFloat(0x3eb33333) + R127f.x);
|
|
}
|
|
activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true;
|
|
// export
|
|
passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
|
|
}
|