mirror of
https://github.com/cemu-project/cemu_graphic_packs.git
synced 2024-11-25 02:56:53 +01:00
[XCX] Re-re-adds custom shaders removed in red-sky fix as enhancements
Re-adds custom shaders removed in red-sky fix as enhancements Initial commit is likely broken on some resolutions and Intel GPUs To-do Detecting res from shader instead of variables and new shader dumps Baseline is: Works on nvidia. Intel/AMD/3dfx/Integrated GPUs, not my problem.
This commit is contained in:
getdls
parent
0960a6fd09
commit
9bb45c0b83
@ -5,29 +5,6 @@ path = "Xenoblade Chronicles X/Enhancements/Contrasty"
|
||||
description = This pack tweaks the colours and contrast to whatever preset you set it as. You can also make your own preset by editing the Default preset in the Contrasty folder from the game's graphic packs. Enabling will ignore your other AA settings.
|
||||
version = 3
|
||||
|
||||
|
||||
[Preset]
|
||||
name = Default
|
||||
$redShadows = 1.0
|
||||
$greenShadows = 1.0
|
||||
$blueSadows = 1.0
|
||||
$redMid = 1.0
|
||||
$greenMid = 1.0
|
||||
$blueMid = 1.0
|
||||
$redHilight = 1.0
|
||||
$greenHilight =1.0
|
||||
$blueHilight = 1.0
|
||||
|
||||
$contrastCurve = 0.0
|
||||
$hazeFactor = 1.0
|
||||
$bloom = 1.0
|
||||
$gamma = 1.0
|
||||
$exposure = 1.0
|
||||
$vibrance = 0.0
|
||||
$crushContrast = 0.0
|
||||
$bleach = 1.0
|
||||
$sharp_mix = 0.0
|
||||
|
||||
[Preset]
|
||||
name = High Contrasty
|
||||
$redShadows = 1.0
|
||||
@ -92,4 +69,26 @@ $exposure = 1.0
|
||||
$vibrance = 0.0
|
||||
$crushContrast = 0.00
|
||||
$bleach = 0.85
|
||||
$sharp_mix = 0.1
|
||||
$sharp_mix = 0.1
|
||||
|
||||
[Preset]
|
||||
name = Default
|
||||
$redShadows = 1.0
|
||||
$greenShadows = 1.0
|
||||
$blueSadows = 1.0
|
||||
$redMid = 1.0
|
||||
$greenMid = 1.0
|
||||
$blueMid = 1.0
|
||||
$redHilight = 1.0
|
||||
$greenHilight =1.0
|
||||
$blueHilight = 1.0
|
||||
|
||||
$contrastCurve = 0.0
|
||||
$hazeFactor = 1.0
|
||||
$bloom = 1.0
|
||||
$gamma = 1.0
|
||||
$exposure = 1.0
|
||||
$vibrance = 0.0
|
||||
$crushContrast = 0.0
|
||||
$bleach = 1.0
|
||||
$sharp_mix = 0.0
|
||||
@ -0,0 +1,567 @@
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
// shader 5eb82314ffb8484e
|
||||
//cross fade blur prel
|
||||
uniform ivec4 uf_remappedPS[7];
|
||||
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e12000 res 320x180x1 dim 1 tm: 4 format 0820 compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
layout(location = 1) out vec4 passPixelColor1;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R0f = vec4(0.0);
|
||||
vec4 R1f = vec4(0.0);
|
||||
vec4 R2f = vec4(0.0);
|
||||
vec4 R3f = vec4(0.0);
|
||||
vec4 R4f = vec4(0.0);
|
||||
vec4 R5f = vec4(0.0);
|
||||
vec4 R6f = vec4(0.0);
|
||||
vec4 R7f = vec4(0.0);
|
||||
vec4 R8f = vec4(0.0);
|
||||
vec4 R9f = vec4(0.0);
|
||||
vec4 R10f = vec4(0.0);
|
||||
vec4 R11f = vec4(0.0);
|
||||
vec4 R12f = vec4(0.0);
|
||||
vec4 R13f = vec4(0.0);
|
||||
vec4 R14f = vec4(0.0);
|
||||
vec4 R15f = vec4(0.0);
|
||||
vec4 R16f = vec4(0.0);
|
||||
vec4 R17f = vec4(0.0);
|
||||
vec4 R123f = vec4(0.0);
|
||||
vec4 R124f = vec4(0.0);
|
||||
vec4 R125f = 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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
R0f = passParameterSem0;
|
||||
R14f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
|
||||
// 0
|
||||
R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x);
|
||||
R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y);
|
||||
R0f.z = R0f.x + intBitsToFloat(uf_remappedPS[0].z);
|
||||
R0f.w = R0f.y + intBitsToFloat(uf_remappedPS[0].w);
|
||||
R17f.w = R14f.w;
|
||||
PS0f = R17f.w;
|
||||
// 1
|
||||
R2f.x = R0f.x + intBitsToFloat(uf_remappedPS[1].x);
|
||||
R2f.y = R0f.y + intBitsToFloat(uf_remappedPS[1].y);
|
||||
R1f.z = R0f.x + intBitsToFloat(uf_remappedPS[1].z);
|
||||
R1f.w = R0f.y + intBitsToFloat(uf_remappedPS[1].w);
|
||||
R16f.w = R14f.w;
|
||||
PS1f = R16f.w;
|
||||
// 2
|
||||
R3f.x = R0f.x + intBitsToFloat(uf_remappedPS[2].x);
|
||||
R3f.y = R0f.y + intBitsToFloat(uf_remappedPS[2].y);
|
||||
R2f.z = R0f.x + intBitsToFloat(uf_remappedPS[2].z);
|
||||
R2f.w = R0f.y + intBitsToFloat(uf_remappedPS[2].w);
|
||||
// 3
|
||||
R4f.x = R0f.x + intBitsToFloat(uf_remappedPS[3].x);
|
||||
R4f.y = R0f.y + intBitsToFloat(uf_remappedPS[3].y);
|
||||
R3f.z = R0f.x + intBitsToFloat(uf_remappedPS[3].z);
|
||||
R3f.w = R0f.y + intBitsToFloat(uf_remappedPS[3].w);
|
||||
R5f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
|
||||
R6f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw);
|
||||
R7f.xyzw = (texture(textureUnitPS0, R2f.xy).xyzw);
|
||||
R9f.xyzw = (texture(textureUnitPS0, R1f.zw).xyzw);
|
||||
R8f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
|
||||
R10f.xyzw = (texture(textureUnitPS0, R2f.zw).xyzw);
|
||||
R11f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw);
|
||||
R12f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw);
|
||||
// 0
|
||||
R4f.x = R0f.x + intBitsToFloat(uf_remappedPS[4].x);
|
||||
R4f.y = R0f.y + intBitsToFloat(uf_remappedPS[4].y);
|
||||
R3f.z = R0f.x + intBitsToFloat(uf_remappedPS[4].z);
|
||||
R3f.w = R0f.y + intBitsToFloat(uf_remappedPS[4].w);
|
||||
R127f.x = R5f.w + -(0.5);
|
||||
R127f.x *= 2.0;
|
||||
R127f.x = clamp(R127f.x, 0.0, 1.0);
|
||||
PS0f = R127f.x;
|
||||
// 1
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
R0f.x = backupReg0f + intBitsToFloat(uf_remappedPS[5].z);
|
||||
R0f.y = backupReg1f + intBitsToFloat(uf_remappedPS[5].w);
|
||||
R2f.z = backupReg0f + intBitsToFloat(uf_remappedPS[5].x);
|
||||
R2f.w = backupReg1f + intBitsToFloat(uf_remappedPS[5].y);
|
||||
PS1f = R5f.x + -(0.0);
|
||||
// 2
|
||||
R126f.x = R127f.x + 1.0;
|
||||
PV0f.y = R5f.z + -(0.0);
|
||||
PV0f.z = R5f.y + -(0.0);
|
||||
R127f.w = R6f.w + -(0.5);
|
||||
R127f.w *= 2.0;
|
||||
R127f.w = clamp(R127f.w, 0.0, 1.0);
|
||||
R125f.x = (R127f.x * PS1f + R14f.x);
|
||||
PS0f = R125f.x;
|
||||
// 3
|
||||
PV1f.x = R6f.x + -(0.0);
|
||||
PV1f.y = R6f.y + -(0.0);
|
||||
R123f.z = (R127f.x * PV0f.y + R14f.z);
|
||||
PV1f.z = R123f.z;
|
||||
R123f.w = (R127f.x * PV0f.z + R14f.y);
|
||||
PV1f.w = R123f.w;
|
||||
PS1f = R6f.z + -(0.0);
|
||||
// 4
|
||||
R3f.x = R7f.w + -(0.5);
|
||||
R3f.x *= 2.0;
|
||||
R3f.x = clamp(R3f.x, 0.0, 1.0);
|
||||
R3f.y = R126f.x + R127f.w;
|
||||
R1f.z = (R127f.w * PV1f.y + PV1f.w);
|
||||
R1f.w = (R127f.w * PV1f.x + R125f.x);
|
||||
R2f.y = (R127f.w * PS1f + PV1f.z);
|
||||
PS0f = R2f.y;
|
||||
R4f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw);
|
||||
R13f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw);
|
||||
R15f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
|
||||
R0f.xyzw = (texture(textureUnitPS0, R2f.zw).xyzw);
|
||||
// 0
|
||||
R126f.x = R3f.y + R3f.x;
|
||||
PV0f.y = R7f.z + -(0.0);
|
||||
PV0f.z = R7f.y + -(0.0);
|
||||
PV0f.w = R7f.x + -(0.0);
|
||||
R127f.z = R9f.w + -(0.5);
|
||||
R127f.z *= 2.0;
|
||||
R127f.z = clamp(R127f.z, 0.0, 1.0);
|
||||
PS0f = R127f.z;
|
||||
// 1
|
||||
R123f.x = (R3f.x * PV0f.w + R1f.w);
|
||||
PV1f.x = R123f.x;
|
||||
R127f.y = R5f.w + -(intBitsToFloat(0x3f666666));
|
||||
R126f.z = (R3f.x * PV0f.y + R2f.y);
|
||||
R127f.w = (R3f.x * PV0f.z + R1f.z);
|
||||
PS1f = R9f.x + -(0.0);
|
||||
// 2
|
||||
PV0f.x = R9f.y + -(0.0);
|
||||
R126f.y = R126f.x + R127f.z;
|
||||
R124f.z = R8f.w + -(0.5);
|
||||
R124f.z *= 2.0;
|
||||
R124f.z = clamp(R124f.z, 0.0, 1.0);
|
||||
PV0f.w = R9f.z + -(0.0);
|
||||
R125f.z = (R127f.z * PS1f + PV1f.x);
|
||||
PS0f = R125f.z;
|
||||
// 3
|
||||
R126f.x = (R127f.z * PV0f.w + R126f.z);
|
||||
R125f.y = (R127f.z * PV0f.x + R127f.w);
|
||||
R126f.z = R127f.y * intBitsToFloat(0x41200000);
|
||||
R126f.z = clamp(R126f.z, 0.0, 1.0);
|
||||
R127f.w = -(R14f.x) + R5f.x;
|
||||
R127f.z = -(R14f.y) + R5f.y;
|
||||
PS1f = R127f.z;
|
||||
// 4
|
||||
R125f.x = R6f.w + -(intBitsToFloat(0x3f666666));
|
||||
R124f.y = -(R14f.z) + R5f.z;
|
||||
R5f.z = R7f.w + -(intBitsToFloat(0x3f666666));
|
||||
PV0f.w = R8f.x + -(0.0);
|
||||
R127f.y = R8f.y + -(0.0);
|
||||
PS0f = R127f.y;
|
||||
// 5
|
||||
backupReg0f = R126f.y;
|
||||
backupReg1f = R125f.z;
|
||||
PV1f.x = R8f.z + -(0.0);
|
||||
R126f.y = R8f.w + -(intBitsToFloat(0x3f666666));
|
||||
R125f.z = backupReg0f + R124f.z;
|
||||
R125f.w = R10f.w + -(0.5);
|
||||
R125f.w *= 2.0;
|
||||
R125f.w = clamp(R125f.w, 0.0, 1.0);
|
||||
R126f.w = (R124f.z * PV0f.w + backupReg1f);
|
||||
PS1f = R126f.w;
|
||||
// 6
|
||||
backupReg0f = R126f.x;
|
||||
backupReg1f = R127f.y;
|
||||
backupReg2f = R127f.z;
|
||||
R126f.x = (R127f.w * R126f.z + R14f.x);
|
||||
R127f.y = (R124f.z * PV1f.x + backupReg0f);
|
||||
R127f.z = (R124f.z * backupReg1f + R125f.y);
|
||||
R124f.w = (backupReg2f * R126f.z + R14f.y);
|
||||
R5f.w = R125f.x * intBitsToFloat(0x41200000);
|
||||
R5f.w = clamp(R5f.w, 0.0, 1.0);
|
||||
PS0f = R5f.w;
|
||||
// 7
|
||||
backupReg0f = R124f.y;
|
||||
backupReg1f = R126f.z;
|
||||
R125f.x = -(R14f.x) + R6f.x;
|
||||
R124f.y = -(R14f.y) + R6f.y;
|
||||
R126f.z = (backupReg0f * backupReg1f + R14f.z);
|
||||
R6f.w = -(R14f.z) + R6f.z;
|
||||
R1f.w = -(R14f.x) + R7f.x;
|
||||
PS1f = R1f.w;
|
||||
// 8
|
||||
backupReg0f = R126f.y;
|
||||
R127f.x = R5f.z * intBitsToFloat(0x41200000);
|
||||
R127f.x = clamp(R127f.x, 0.0, 1.0);
|
||||
R126f.y = -(R14f.z) + R7f.z;
|
||||
R124f.z = -(R14f.y) + R7f.y;
|
||||
R7f.w = R9f.w + -(intBitsToFloat(0x3f666666));
|
||||
R2f.w = backupReg0f * intBitsToFloat(0x41200000);
|
||||
R2f.w = clamp(R2f.w, 0.0, 1.0);
|
||||
PS0f = R2f.w;
|
||||
// 9
|
||||
R124f.x = -(R14f.z) + R8f.z;
|
||||
R125f.y = -(R14f.y) + R8f.y;
|
||||
R8f.z = -(R14f.x) + R8f.x;
|
||||
R127f.w = R10f.x + -(0.0);
|
||||
PS1f = R10f.y + -(0.0);
|
||||
// 10
|
||||
R8f.x = R10f.w + -(intBitsToFloat(0x3f666666));
|
||||
R6f.y = R125f.z + R125f.w;
|
||||
PV0f.z = R10f.z + -(0.0);
|
||||
R8f.w = R11f.w + -(0.5);
|
||||
R8f.w *= 2.0;
|
||||
R8f.w = clamp(R8f.w, 0.0, 1.0);
|
||||
R5f.x = (R125f.w * PS1f + R127f.z);
|
||||
PS0f = R5f.x;
|
||||
// 11
|
||||
backupReg0f = R126f.x;
|
||||
backupReg1f = R124f.z;
|
||||
R126f.x = max(R14f.x, backupReg0f);
|
||||
R5f.y = (R125f.w * R127f.w + R126f.w);
|
||||
R124f.z = max(R14f.z, R126f.z);
|
||||
R3f.w = (R125f.w * PV0f.z + R127f.y);
|
||||
R126f.w = (backupReg1f * R127f.x + R14f.y);
|
||||
PS1f = R126f.w;
|
||||
// 12
|
||||
backupReg0f = R125f.x;
|
||||
backupReg1f = R126f.y;
|
||||
R125f.x = max(R14f.y, R124f.w);
|
||||
R126f.y = (R6f.w * R5f.w + R14f.z);
|
||||
R126f.z = (R124f.y * R5f.w + R14f.y);
|
||||
R124f.w = (backupReg0f * R5f.w + R14f.x);
|
||||
R125f.z = (backupReg1f * R127f.x + R14f.z);
|
||||
PS0f = R125f.z;
|
||||
// 13
|
||||
backupReg0f = R127f.x;
|
||||
backupReg1f = R9f.z;
|
||||
R127f.x = (R1f.w * backupReg0f + R14f.x);
|
||||
R124f.y = -(R14f.x) + R9f.x;
|
||||
R9f.z = R7f.w * intBitsToFloat(0x41200000);
|
||||
R9f.z = clamp(R9f.z, 0.0, 1.0);
|
||||
R125f.w = -(R14f.y) + R9f.y;
|
||||
R1f.w = -(R14f.z) + backupReg1f;
|
||||
PS1f = R1f.w;
|
||||
// 14
|
||||
backupReg0f = R124f.x;
|
||||
backupReg1f = R125f.y;
|
||||
R124f.x = (backupReg0f * R2f.w + R14f.z);
|
||||
R125f.y = R8f.x * intBitsToFloat(0x41200000);
|
||||
R125f.y = clamp(R125f.y, 0.0, 1.0);
|
||||
R127f.z = (backupReg1f * R2f.w + R14f.y);
|
||||
R127f.w = (R8f.z * R2f.w + R14f.x);
|
||||
R2f.w = -(R14f.y) + R10f.y;
|
||||
PS0f = R2f.w;
|
||||
// 15
|
||||
backupReg0f = R10f.x;
|
||||
backupReg1f = R10f.z;
|
||||
R10f.x = -(R14f.x) + backupReg0f;
|
||||
R127f.y = R11f.y + -(0.0);
|
||||
R10f.zwy = vec3(-(R14f.z),R11f.x,R11f.z) + vec3(backupReg1f,-(0.0),-(0.0));
|
||||
PS1f = R10f.y;
|
||||
// 16
|
||||
backupReg0f = R126f.x;
|
||||
backupReg1f = R124f.z;
|
||||
backupReg2f = R126f.y;
|
||||
R126f.x = max(backupReg0f, R124f.w);
|
||||
R126f.y = max(R125f.x, R126f.z);
|
||||
R126f.z = R6f.y + R8f.w;
|
||||
R7f.w = R12f.w + -(0.5);
|
||||
R7f.w *= 2.0;
|
||||
R7f.w = clamp(R7f.w, 0.0, 1.0);
|
||||
R124f.z = max(backupReg1f, backupReg2f);
|
||||
PS0f = R124f.z;
|
||||
// 17
|
||||
R8f.x = max(R124f.x, R125f.z);
|
||||
R9f.y = max(R127f.z, R126f.w);
|
||||
R127f.z = max(R127f.w, R127f.x);
|
||||
R127f.w = (R124f.y * R9f.z + R14f.x);
|
||||
R124f.y = (R125f.w * R9f.z + R14f.y);
|
||||
PS1f = R124f.y;
|
||||
// 18
|
||||
backupReg0f = R127f.y;
|
||||
R127f.x = (R1f.w * R9f.z + R14f.z);
|
||||
R127f.y = (R10f.x * R125f.y + R14f.x);
|
||||
R125f.z = (R2f.w * R125f.y + R14f.y);
|
||||
R1f.w = (R10f.z * R125f.y + R14f.z);
|
||||
R2f.w = (R8f.w * backupReg0f + R5f.x);
|
||||
PS0f = R2f.w;
|
||||
// 19
|
||||
backupReg0f = R10f.y;
|
||||
R10f.x = (R8f.w * R10f.w + R5f.y);
|
||||
R10f.y = R12f.x + -(0.0);
|
||||
R9f.z = (R8f.w * backupReg0f + R3f.w);
|
||||
R8f.w = R12f.y + -(0.0);
|
||||
R9f.x = R12f.z + -(0.0);
|
||||
PS1f = R9f.x;
|
||||
// 20
|
||||
R7f.x = R12f.w + -(intBitsToFloat(0x3f666666));
|
||||
R8f.y = R11f.w + -(intBitsToFloat(0x3f666666));
|
||||
R10f.z = R126f.z + R7f.w;
|
||||
R10f.w = max(R126f.y, R124f.y);
|
||||
R7f.y = max(R124f.z, R127f.x);
|
||||
PS0f = R7f.y;
|
||||
// 21
|
||||
backupReg0f = R9f.y;
|
||||
R6f.x = R13f.w + -(intBitsToFloat(0x3f666666));
|
||||
R9f.y = max(R126f.x, R127f.w);
|
||||
R8f.z = max(R127f.y, R127f.z);
|
||||
R9f.w = R4f.w + -(0.5);
|
||||
R9f.w *= 2.0;
|
||||
R9f.w = clamp(R9f.w, 0.0, 1.0);
|
||||
R5f.z = max(R125f.z, backupReg0f);
|
||||
PS1f = R5f.z;
|
||||
// 0
|
||||
R127f.x = (R7f.w * R9f.x + R9f.z);
|
||||
R127f.y = max(R1f.w, R8f.x);
|
||||
R125f.z = R8f.y * intBitsToFloat(0x41200000);
|
||||
R125f.z = clamp(R125f.z, 0.0, 1.0);
|
||||
R127f.w = (R7f.w * R10f.y + R10f.x);
|
||||
R124f.y = -(R14f.z) + R11f.z;
|
||||
PS0f = R124f.y;
|
||||
// 1
|
||||
R125f.x = -(R14f.y) + R11f.y;
|
||||
R11f.y = R7f.x * intBitsToFloat(0x41200000);
|
||||
R11f.y = clamp(R11f.y, 0.0, 1.0);
|
||||
R127f.z = (R7f.w * R8f.w + R2f.w);
|
||||
R125f.w = -(R14f.x) + R11f.x;
|
||||
R125f.y = -(R14f.y) + R12f.y;
|
||||
PS1f = R125f.y;
|
||||
// 2
|
||||
backupReg0f = R12f.x;
|
||||
R12f.x = -(R14f.z) + R12f.z;
|
||||
R126f.yzw = vec3(R4f.x,-(R14f.x),R4f.y) + vec3(-(0.0),backupReg0f,-(0.0));
|
||||
R126f.x = R4f.z + -(0.0);
|
||||
PS0f = R126f.x;
|
||||
// 3
|
||||
backupReg0f = R10f.z;
|
||||
R124f.x = R4f.w + -(intBitsToFloat(0x3f666666));
|
||||
R8f.y = R6f.x * intBitsToFloat(0x41200000);
|
||||
R8f.y = clamp(R8f.y, 0.0, 1.0);
|
||||
R10f.z = R13f.w + -(0.5);
|
||||
R10f.z *= 2.0;
|
||||
R10f.z = clamp(R10f.z, 0.0, 1.0);
|
||||
R124f.w = backupReg0f + R9f.w;
|
||||
R12f.y = -(R14f.x) + R13f.x;
|
||||
PS1f = R12f.y;
|
||||
// 4
|
||||
backupReg0f = R127f.x;
|
||||
R127f.x = -(R14f.y) + R13f.y;
|
||||
R10f.y = max(R9f.y, R8f.z);
|
||||
R124f.z = R15f.w + -(intBitsToFloat(0x3f666666));
|
||||
R12f.w = -(R14f.z) + R13f.z;
|
||||
R9f.y = (R9f.w * R126f.x + backupReg0f);
|
||||
PS0f = R9f.y;
|
||||
// 5
|
||||
backupReg0f = R124f.x;
|
||||
backupReg1f = R7f.y;
|
||||
backupReg2f = R10f.w;
|
||||
R124f.x = (R9f.w * R126f.y + R127f.w);
|
||||
R7f.y = backupReg0f * intBitsToFloat(0x41200000);
|
||||
R7f.y = clamp(R7f.y, 0.0, 1.0);
|
||||
R12f.z = max(backupReg1f, R127f.y);
|
||||
R10f.w = max(backupReg2f, R5f.z);
|
||||
R5f.z = -(R14f.x) + R4f.x;
|
||||
PS1f = R5f.z;
|
||||
// 6
|
||||
backupReg0f = R127f.z;
|
||||
R126f.x = (R125f.w * R125f.z + R14f.x);
|
||||
R126f.y = (R124f.y * R125f.z + R14f.z);
|
||||
R127f.z = (R9f.w * R126f.w + backupReg0f);
|
||||
R125f.w = (R125f.x * R125f.z + R14f.y);
|
||||
R127f.y = (R12f.x * R11f.y + R14f.z);
|
||||
PS0f = R127f.y;
|
||||
// 7
|
||||
backupReg0f = R125f.y;
|
||||
backupReg1f = R126f.z;
|
||||
R12f.x = -(R14f.z) + R4f.z;
|
||||
R125f.y = R13f.x + -(0.0);
|
||||
R126f.z = (backupReg0f * R11f.y + R14f.y);
|
||||
R126f.w = (backupReg1f * R11f.y + R14f.x);
|
||||
R8f.z = R0f.w + -(0.5);
|
||||
R8f.z *= 2.0;
|
||||
R8f.z = clamp(R8f.z, 0.0, 1.0);
|
||||
PS1f = R8f.z;
|
||||
// 8
|
||||
backupReg0f = R4f.y;
|
||||
R125f.x = R13f.y + -(0.0);
|
||||
R4f.y = -(R14f.y) + backupReg0f;
|
||||
R125f.z = R124f.w + R10f.z;
|
||||
R124f.w = R13f.z + -(0.0);
|
||||
R127f.w = R0f.w + -(intBitsToFloat(0x3f666666));
|
||||
PS0f = R127f.w;
|
||||
// 9
|
||||
backupReg0f = R127f.x;
|
||||
R127f.x = (R12f.w * R8f.y + R14f.z);
|
||||
R124f.y = (backupReg0f * R8f.y + R14f.y);
|
||||
R123f.z = (R12f.y * R8f.y + R14f.x);
|
||||
PV1f.z = R123f.z;
|
||||
R12f.w = R124f.z * intBitsToFloat(0x41200000);
|
||||
R12f.w = clamp(R12f.w, 0.0, 1.0);
|
||||
R4f.x = -(R14f.x) + R15f.x;
|
||||
PS1f = R4f.x;
|
||||
// 10
|
||||
R13f.x = (R10f.z * R125f.y + R124f.x);
|
||||
R125f.y = max(PV1f.z, R126f.w);
|
||||
R124f.z = -(R14f.z) + R15f.z;
|
||||
R126f.w = -(R14f.y) + R15f.y;
|
||||
R124f.x = max(R10f.w, R125f.w);
|
||||
PS0f = R124f.x;
|
||||
// 11
|
||||
backupReg0f = R125f.x;
|
||||
backupReg1f = R124f.y;
|
||||
R125f.x = (R10f.z * R124f.w + R9f.y);
|
||||
R124f.y = (R10f.z * backupReg0f + R127f.z);
|
||||
R10f.z = max(backupReg1f, R126f.z);
|
||||
R125f.w = max(R127f.x, R127f.y);
|
||||
R127f.y = R0f.x + -(0.0);
|
||||
PS1f = R127f.y;
|
||||
// 12
|
||||
backupReg0f = R126f.x;
|
||||
backupReg1f = R126f.y;
|
||||
backupReg2f = R127f.w;
|
||||
R126f.x = (R5f.z * R7f.y + R14f.x);
|
||||
R126f.y = max(R10f.y, backupReg0f);
|
||||
R126f.z = (R12f.x * R7f.y + R14f.z);
|
||||
R127f.w = max(R12f.z, backupReg1f);
|
||||
R5f.z = backupReg2f * intBitsToFloat(0x41200000);
|
||||
R5f.z = clamp(R5f.z, 0.0, 1.0);
|
||||
PS0f = R5f.z;
|
||||
// 13
|
||||
backupReg0f = R4f.y;
|
||||
R12f.x = -(R14f.z) + R0f.z;
|
||||
R4f.y = -(R14f.x) + R0f.x;
|
||||
R127f.z = (backupReg0f * R7f.y + R14f.y);
|
||||
R124f.w = R0f.z + -(0.0);
|
||||
R7f.y = R15f.w + -(0.5);
|
||||
R7f.y *= 2.0;
|
||||
R7f.y = clamp(R7f.y, 0.0, 1.0);
|
||||
PS1f = R7f.y;
|
||||
// 14
|
||||
backupReg0f = R0f.y;
|
||||
backupReg1f = R125f.z;
|
||||
R127f.x = R0f.y + -(0.0);
|
||||
R0f.y = -(R14f.y) + backupReg0f;
|
||||
R125f.z = backupReg1f + R8f.z;
|
||||
R123f.w = (R4f.x * R12f.w + R14f.x);
|
||||
PV0f.w = R123f.w;
|
||||
R0f.x = (R126f.w * R12f.w + R14f.y);
|
||||
PS0f = R0f.x;
|
||||
// 15
|
||||
backupReg0f = R126f.x;
|
||||
R126f.x = max(R126f.y, backupReg0f);
|
||||
R126f.y = max(R124f.x, R127f.z);
|
||||
R127f.z = max(PV0f.w, R125f.y);
|
||||
R123f.w = (R124f.z * R12f.w + R14f.z);
|
||||
PV1f.w = R123f.w;
|
||||
R124f.x = R15f.x + -(0.0);
|
||||
PS1f = R124f.x;
|
||||
// 16
|
||||
backupReg0f = R127f.x;
|
||||
backupReg1f = R126f.z;
|
||||
R127f.x = (R8f.z * R127f.y + R13f.x);
|
||||
R127f.y = (R8f.z * backupReg0f + R124f.y);
|
||||
R126f.z = max(R127f.w, backupReg1f);
|
||||
R127f.w = (R8f.z * R124f.w + R125f.x);
|
||||
R124f.y = max(PV1f.w, R125f.w);
|
||||
PS0f = R124f.y;
|
||||
// 17
|
||||
R123f.x = (R4f.y * R5f.z + R14f.x);
|
||||
PV1f.x = R123f.x;
|
||||
R123f.y = (R0f.y * R5f.z + R14f.y);
|
||||
PV1f.y = R123f.y;
|
||||
R124f.z = max(R0f.x, R10f.z);
|
||||
// 18
|
||||
backupReg0f = R126f.y;
|
||||
R123f.x = (R12f.x * R5f.z + R14f.z);
|
||||
PV0f.x = R123f.x;
|
||||
R126f.y = max(R126f.x, PV1f.x);
|
||||
PV0f.z = R15f.z + -(0.0);
|
||||
PV0f.w = R15f.y + -(0.0);
|
||||
R5f.z = max(backupReg0f, PV1f.y);
|
||||
PS0f = R5f.z;
|
||||
// 19
|
||||
backupReg0f = R127f.x;
|
||||
backupReg1f = R126f.z;
|
||||
backupReg2f = R127f.w;
|
||||
R127f.x = (R7f.y * PV0f.w + R127f.y);
|
||||
R127f.y = (R7f.y * R124f.x + backupReg0f);
|
||||
R126f.z = R125f.z + R7f.y;
|
||||
R127f.w = max(backupReg1f, PV0f.x);
|
||||
R125f.w = (R7f.y * PV0f.z + backupReg2f);
|
||||
PS1f = R125f.w;
|
||||
// 20
|
||||
PV0f.x = max(R10f.y, R127f.z);
|
||||
PV0f.z = max(R12f.z, R124f.y);
|
||||
PV0f.w = max(R10f.w, R124f.z);
|
||||
R127f.z = 1.0 / R6f.y;
|
||||
PS0f = R127f.z;
|
||||
// 21
|
||||
backupReg0f = R126f.y;
|
||||
R124f.x = max(PV0f.w, R5f.z);
|
||||
R126f.y = max(PV0f.x, backupReg0f);
|
||||
R5f.z = R5f.y * PS0f;
|
||||
R14f.w = max(PV0f.z, R127f.w);
|
||||
PS1f = 1.0 / R126f.z;
|
||||
// 22
|
||||
backupReg0f = R3f.w;
|
||||
R12f.x = R5f.x * R127f.z;
|
||||
PV0f.x = R12f.x;
|
||||
R5f.y = R127f.y * PS1f;
|
||||
PV0f.y = R5f.y;
|
||||
R14f.z = R127f.x * PS1f;
|
||||
PV0f.z = R14f.z;
|
||||
R3f.w = backupReg0f * R127f.z;
|
||||
PV0f.w = R3f.w;
|
||||
R15f.z = R125f.w * PS1f;
|
||||
PS0f = R15f.z;
|
||||
// 23
|
||||
backupReg0f = R10f.y;
|
||||
backupReg1f = R12f.z;
|
||||
R5f.x = R10f.w + -(PV0f.x);
|
||||
R10f.y = backupReg0f + -(R5f.z);
|
||||
R12f.z = -(PV0f.y) + R126f.y;
|
||||
R10f.w = backupReg1f + -(PV0f.w);
|
||||
R6f.y = -(PV0f.z) + R124f.x;
|
||||
PS1f = R6f.y;
|
||||
// 0
|
||||
PV0f.x = -(R15f.z) + R14f.w;
|
||||
R17f.y = (R5f.x * intBitsToFloat(uf_remappedPS[6].x) + R12f.x);
|
||||
R17f.z = (R10f.w * intBitsToFloat(uf_remappedPS[6].x) + R3f.w);
|
||||
R17f.x = (R10f.y * intBitsToFloat(uf_remappedPS[6].x) + R5f.z);
|
||||
PS0f = R17f.x;
|
||||
// 1
|
||||
R16f.x = (R12f.z * intBitsToFloat(uf_remappedPS[6].x) + R5f.y);
|
||||
PV1f.x = R16f.x;
|
||||
R16f.y = (R6f.y * intBitsToFloat(uf_remappedPS[6].x) + R14f.z);
|
||||
PV1f.y = R16f.y;
|
||||
R16f.z = (PV0f.x * intBitsToFloat(uf_remappedPS[6].x) + R15f.z);
|
||||
PV1f.z = R16f.z;
|
||||
// 2
|
||||
R1f.xyz = vec3(PV1f.x,PV1f.y,PV1f.z);
|
||||
R1f.w = R16f.w;
|
||||
// 3
|
||||
R0f.xyz = vec3(R17f.x,R17f.y,R17f.z);
|
||||
R0f.w = R17f.w;
|
||||
// export
|
||||
passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
|
||||
passPixelColor1 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
|
||||
}
|
||||
@ -0,0 +1,191 @@
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
// shader 840947e29015aa9a
|
||||
//BB cliff
|
||||
|
||||
const float dither = $dither ;
|
||||
const float scaleShader = $scaleShader;
|
||||
const float scaleBlur = $scaleBlur;
|
||||
|
||||
const int sampleScale = 4;
|
||||
|
||||
highp float lineRand(vec2 co)
|
||||
{
|
||||
highp float a = 12.9898;
|
||||
highp float b = 78.233;
|
||||
highp float c = 43758.5453;
|
||||
highp float dt = dot(co.xy, vec2(a, b));
|
||||
highp float sn = mod(dt, 3.14);
|
||||
return fract(sin(sn) * c);
|
||||
}
|
||||
|
||||
|
||||
uniform ivec4 uf_remappedPS[3];
|
||||
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4386000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 1) in vec4 passParameterSem1;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
|
||||
// FabriceNeyret2 CC, single shader gaussian by intermediate MIPmap level. www.shadertoy.com/view/ltScRG
|
||||
const int samples = 8 * sampleScale, //8 or 4 balances xy position
|
||||
LOD = 2, // gaussian done on MIPmap at scale LOD
|
||||
sLOD = 1 << LOD; // tile size = 2^LOD
|
||||
const float sigma = float(samples) * .25;
|
||||
|
||||
float gaussian(vec2 i) {
|
||||
return exp(-.5* dot(i /= sigma, i)) / (6.28 * sigma*sigma);
|
||||
}
|
||||
|
||||
vec4 blur(sampler2D sp, vec2 U, vec2 scale) {
|
||||
vec4 O = vec4(0);
|
||||
int s = samples / sLOD;
|
||||
|
||||
for (int i = 0; i < s*s; i++) {
|
||||
vec2 d = vec2(i%s, i / s)*float(sLOD) - float(samples) / 2.;
|
||||
O += gaussian(d) * textureLod(sp, U + scale * d, float(LOD));
|
||||
}
|
||||
|
||||
return O / O.a;
|
||||
}
|
||||
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R0f = vec4(0.0);
|
||||
vec4 R1f = vec4(0.0);
|
||||
vec4 R2f = vec4(0.0);
|
||||
vec4 R3f = vec4(0.0);
|
||||
vec4 R4f = vec4(0.0);
|
||||
vec4 R5f = vec4(0.0);
|
||||
vec4 R6f = vec4(0.0);
|
||||
vec4 R7f = vec4(0.0);
|
||||
vec4 R8f = vec4(0.0);
|
||||
vec4 R123f = 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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
R0f = passParameterSem0;
|
||||
R1f = passParameterSem1;
|
||||
R0f.xy = R0f.xy - (lineRand(gl_FragCoord.xy)*0.0012 *dither);
|
||||
R0f.xy = R0f.xy + (lineRand(gl_FragCoord.xy*vec2(0.1, 0.09))*0.0011 *dither);
|
||||
// 0
|
||||
R2f.x = R1f.x + intBitsToFloat(uf_remappedPS[0].x);
|
||||
R2f.y = R1f.y + intBitsToFloat(uf_remappedPS[0].y);
|
||||
R0f.z = R1f.x + intBitsToFloat(uf_remappedPS[0].z);
|
||||
R0f.w = R1f.y + intBitsToFloat(uf_remappedPS[0].w);
|
||||
// 1
|
||||
backupReg0f = R1f.x;
|
||||
backupReg1f = R1f.y;
|
||||
backupReg0f = R1f.x;
|
||||
backupReg1f = R1f.y;
|
||||
R1f.xyz = vec3(backupReg0f,backupReg1f,backupReg0f) + vec3(intBitsToFloat(uf_remappedPS[1].x),intBitsToFloat(uf_remappedPS[1].y),intBitsToFloat(uf_remappedPS[1].z));
|
||||
R1f.w = backupReg1f + intBitsToFloat(uf_remappedPS[1].w);
|
||||
|
||||
vec2 coord = passParameterSem0.xy*textureSize(textureUnitPS0, 0);
|
||||
vec2 ps = vec2(1.0) / textureSize(textureUnitPS0, 0);
|
||||
vec2 uv = coord * ps;
|
||||
|
||||
|
||||
R3f.xyz = (texture(textureUnitPS1, R2f.xy).xyz);
|
||||
R4f.xyz = (texture(textureUnitPS1, R0f.zw).xyz);
|
||||
R5f.xyz = (texture(textureUnitPS1, R1f.xy).xyz);
|
||||
R6f.xyz = (texture(textureUnitPS1, R1f.zw).xyz);
|
||||
R2f.xyz = blur(textureUnitPS0, R2f.xy, ps*scaleBlur).xyz;
|
||||
R7f.xyz = R2f.xyz;
|
||||
R8f.xyz = R2f.xyz;
|
||||
R1f.xyz = R2f.xyz;
|
||||
//R2f.xyz = (texture(textureUnitPS0, R2f.xy).xyz);
|
||||
//R7f.xyz = (texture(textureUnitPS0, R0f.zw).xyz);
|
||||
//R8f.xyz = (texture(textureUnitPS0, R1f.xy).xyz);
|
||||
//R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz);
|
||||
// 0
|
||||
tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV0f.x = tempf.x;
|
||||
PV0f.y = tempf.x;
|
||||
PV0f.z = tempf.x;
|
||||
PV0f.w = tempf.x;
|
||||
R127f.w = tempf.x;
|
||||
R127f.z = R2f.x + R7f.x;
|
||||
PS0f = R127f.z;
|
||||
// 1
|
||||
tempf.x = dot(vec4(R4f.x,R4f.y,R4f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV1f.x = tempf.x;
|
||||
PV1f.y = tempf.x;
|
||||
PV1f.z = tempf.x;
|
||||
PV1f.w = tempf.x;
|
||||
R127f.y = R2f.y + R7f.y;
|
||||
PS1f = R127f.y;
|
||||
// 2
|
||||
tempf.x = dot(vec4(R5f.x,R5f.y,R5f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV0f.x = tempf.x;
|
||||
PV0f.y = tempf.x;
|
||||
PV0f.z = tempf.x;
|
||||
PV0f.w = tempf.x;
|
||||
PS0f = R127f.w + PV1f.x;
|
||||
// 3
|
||||
tempf.x = dot(vec4(R6f.x,R6f.y,R6f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV1f.x = tempf.x;
|
||||
PV1f.y = tempf.x;
|
||||
PV1f.z = tempf.x;
|
||||
PV1f.w = tempf.x;
|
||||
PS1f = PS0f + PV0f.x;
|
||||
// 4
|
||||
PV0f.y = PS1f + PV1f.x;
|
||||
PV0f.z = R127f.y + R8f.y;
|
||||
PV0f.w = R2f.z + R7f.z;
|
||||
// 5
|
||||
R123f.x = (PV0f.y * 0.25 + -(R0f.x));
|
||||
PV1f.x = R123f.x;
|
||||
PV1f.y = R127f.z + R8f.x;
|
||||
PV1f.z = PV0f.z + R1f.y;
|
||||
PV1f.w = PV0f.w + R8f.z;
|
||||
// 6
|
||||
PV0f.x = PV1f.y + R1f.x;
|
||||
PV0f.y = PV1f.w + R1f.z;
|
||||
PV0f.z = PV1f.z * 0.25;
|
||||
PV0f.w = max(PV1f.x, -(PV1f.x));
|
||||
// 7
|
||||
backupReg0f = R0f.y;
|
||||
PV1f.x = PV0f.x * 0.25;
|
||||
PV1f.y = PV0f.y * 0.25;
|
||||
PV1f.z = backupReg0f * PV0f.w;
|
||||
PV1f.z = clamp(PV1f.z, 0.0, 1.0);
|
||||
PV1f.w = max(PV0f.z, 0.0);
|
||||
// 8
|
||||
PV0f.x = max(PV1f.y, 0.0);
|
||||
R0f.y = min(PV1f.w, 4.0);
|
||||
PV0f.z = max(PV1f.x, 0.0);
|
||||
tempResultf = log2(PV1f.z);
|
||||
if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
|
||||
PS0f = tempResultf;
|
||||
// 9
|
||||
PV1f.x = PS0f * intBitsToFloat(uf_remappedPS[2].w);
|
||||
R0f.z = min(PV0f.x, 4.0);
|
||||
R0f.x = min(PV0f.z, 4.0);
|
||||
PS1f = R0f.x;
|
||||
// 10
|
||||
PS0f = exp2(PV1f.x);
|
||||
// 11
|
||||
R0f.w = PS0f * intBitsToFloat(uf_remappedPS[2].z);
|
||||
// export
|
||||
passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
|
||||
}
|
||||
@ -0,0 +1,131 @@
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
// shader 810cde937ebbdf9f
|
||||
//de-band sky, replaced by format convert. Keep around for testing
|
||||
const float dither = $dither ;
|
||||
uniform ivec4 uf_remappedPS[5];
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
|
||||
highp float lineRand(vec2 co)
|
||||
{
|
||||
highp float a = 12.9898;
|
||||
highp float b = 78.233;
|
||||
highp float c = 43758.5453;
|
||||
highp float dt = dot(co.xy, vec2(a, b));
|
||||
highp float sn = mod(dt, 3.14);
|
||||
return fract(sin(sn) * c);
|
||||
}
|
||||
|
||||
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R0f = vec4(0.0);
|
||||
vec4 R1f = vec4(0.0);
|
||||
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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
R0f = passParameterSem0;
|
||||
R0f.xy = R0f.xy - (lineRand(gl_FragCoord.xy)*0.042 *dither);
|
||||
R0f.xy = R0f.xy + (lineRand(gl_FragCoord.xy*vec2(0.1, 0.09))*0.041 *dither);
|
||||
// 0
|
||||
backupReg0f = R0f.x;
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
backupReg1f = R0f.y;
|
||||
backupReg2f = R0f.z;
|
||||
backupReg2f = R0f.z;
|
||||
tempf.x = dot(vec4(backupReg0f,backupReg1f,backupReg2f,-0.0),vec4(backupReg0f,backupReg1f,backupReg2f,0.0));
|
||||
PV0f.x = tempf.x;
|
||||
PV0f.y = tempf.x;
|
||||
PV0f.z = tempf.x;
|
||||
PV0f.w = tempf.x;
|
||||
R1f.w = 1.0;
|
||||
PS0f = R1f.w;
|
||||
// 1
|
||||
tempResultf = 1.0 / sqrt(PV0f.x);
|
||||
PS1f = tempResultf;
|
||||
// 2
|
||||
R127f.x = R0f.x * PS1f;
|
||||
PV0f.x = R127f.x;
|
||||
R127f.y = R0f.y * PS1f;
|
||||
PV0f.y = R127f.y;
|
||||
R127f.z = R0f.z * PS1f;
|
||||
PV0f.z = R127f.z;
|
||||
// 3
|
||||
tempf.x = dot(vec4(intBitsToFloat(uf_remappedPS[0].x),intBitsToFloat(uf_remappedPS[0].y),intBitsToFloat(uf_remappedPS[0].z),-0.0),vec4(PV0f.x,PV0f.y,PV0f.z,0.0));
|
||||
PV1f.x = tempf.x;
|
||||
PV1f.y = tempf.x;
|
||||
PV1f.z = tempf.x;
|
||||
PV1f.w = tempf.x;
|
||||
// 4
|
||||
PV0f.x = intBitsToFloat(uf_remappedPS[1].z) * R127f.z;
|
||||
PV0f.w = max(PV1f.x, -(PV1f.x));
|
||||
// 5
|
||||
R123f.x = (intBitsToFloat(uf_remappedPS[1].y) * R127f.y + PV0f.x);
|
||||
PV1f.x = R123f.x;
|
||||
R127f.z = -(PV0f.w) + 1.0;
|
||||
R127f.z = clamp(R127f.z, 0.0, 1.0);
|
||||
PV1f.z = R127f.z;
|
||||
// 6
|
||||
R123f.w = (intBitsToFloat(uf_remappedPS[1].x) * R127f.x + PV1f.x);
|
||||
R123f.w = clamp(R123f.w, 0.0, 1.0);
|
||||
PV0f.w = R123f.w;
|
||||
tempResultf = log2(PV1f.z);
|
||||
if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
|
||||
PS0f = tempResultf;
|
||||
// 7
|
||||
PV1f.x = PS0f * intBitsToFloat(uf_remappedPS[2].w);
|
||||
tempResultf = log2(PV0f.w);
|
||||
if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
|
||||
PS1f = tempResultf;
|
||||
// 8
|
||||
PV0f.y = PS1f * intBitsToFloat(uf_remappedPS[3].w);
|
||||
R127f.w = exp2(PV1f.x);
|
||||
PS0f = R127f.w;
|
||||
// 9
|
||||
R127f.x = (R127f.z * intBitsToFloat(0x3f733333) + -(PS0f));
|
||||
PV1f.z = PS0f + -(intBitsToFloat(0x3f4ccccd));
|
||||
R126f.x = exp2(PV0f.y);
|
||||
PS1f = R126f.x;
|
||||
// 10
|
||||
PV0f.y = PV1f.z * intBitsToFloat(0x40a00000);
|
||||
PV0f.y = clamp(PV0f.y, 0.0, 1.0);
|
||||
// 11
|
||||
backupReg0f = R127f.w;
|
||||
R127f.w = (R127f.x * PV0f.y + backupReg0f);
|
||||
PV1f.w = R127f.w;
|
||||
// 12
|
||||
R127f.y = (PV1f.w * intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[4].y));
|
||||
R127f.z = (PV1f.w * intBitsToFloat(uf_remappedPS[2].x) + intBitsToFloat(uf_remappedPS[4].x));
|
||||
// 13
|
||||
R123f.x = (R127f.w * intBitsToFloat(uf_remappedPS[2].z) + intBitsToFloat(uf_remappedPS[4].z));
|
||||
PV1f.x = R123f.x;
|
||||
// 14
|
||||
R1f.x = (R126f.x * intBitsToFloat(uf_remappedPS[3].x) + R127f.z);
|
||||
R1f.y = (R126f.x * intBitsToFloat(uf_remappedPS[3].y) + R127f.y);
|
||||
R1f.z = (R126f.x * intBitsToFloat(uf_remappedPS[3].z) + PV1f.x);
|
||||
// export
|
||||
passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
|
||||
}
|
||||
@ -0,0 +1,134 @@
|
||||
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
// shader b253dca415790207
|
||||
// motion blur alpha, disabled while testing, inconsistent results with 60 fps.
|
||||
const float resScale = float($height)/float($gameHeight);
|
||||
|
||||
//const float resScale = 2.0;
|
||||
//const float resScale = 3;
|
||||
uniform ivec4 uf_remappedPS[5];
|
||||
|
||||
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4e12000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R0f = vec4(0.0);
|
||||
vec4 R1f = vec4(0.0);
|
||||
vec4 R2f = vec4(0.0);
|
||||
vec4 R3f = vec4(0.0);
|
||||
vec4 R4f = vec4(0.0);
|
||||
vec4 R5f = vec4(0.0);
|
||||
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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
R0f = passParameterSem0;
|
||||
// 0
|
||||
R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x)/ resScale;
|
||||
R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y)/ resScale;
|
||||
R0f.z = R0f.x + intBitsToFloat(uf_remappedPS[1].x)/ resScale;
|
||||
R0f.w = R0f.y + intBitsToFloat(uf_remappedPS[1].y)/ resScale;
|
||||
R5f.w = 1.0;
|
||||
PS0f = R5f.w;
|
||||
// 1
|
||||
R2f.x = R0f.x + intBitsToFloat(uf_remappedPS[2].x)/ resScale;
|
||||
R2f.y = R0f.y + intBitsToFloat(uf_remappedPS[2].y)/ resScale;
|
||||
R1f.z = R0f.x + intBitsToFloat(uf_remappedPS[3].x)/ resScale;
|
||||
R1f.w = R0f.y + intBitsToFloat(uf_remappedPS[3].y)/ resScale;
|
||||
// 2
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
R0f.x = backupReg0f + intBitsToFloat(uf_remappedPS[4].x)/ resScale;
|
||||
R0f.y = backupReg1f + intBitsToFloat(uf_remappedPS[4].y)/resScale;
|
||||
R3f.xyz = (texture(textureUnitPS0, R1f.xy).xyz);
|
||||
R4f.xyz = (texture(textureUnitPS0, R0f.zw).xyz);
|
||||
R2f.xyz = (texture(textureUnitPS0, R2f.xy).xyz);
|
||||
R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz);
|
||||
R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz);
|
||||
// 0
|
||||
PV0f.x = R3f.y + -(0.5);
|
||||
PV0f.x *= 2.0;
|
||||
PV0f.y = R3f.x + -(0.5);
|
||||
PV0f.y *= 2.0;
|
||||
R127f.z = R4f.x + -(0.5);
|
||||
R127f.z *= 2.0;
|
||||
R127f.w = R4f.y + -(0.5);
|
||||
R127f.w *= 2.0;
|
||||
PS0f = R3f.z * intBitsToFloat(uf_remappedPS[0].z);
|
||||
// 1
|
||||
R123f.x = (R4f.z * intBitsToFloat(uf_remappedPS[1].z) + PS0f);
|
||||
PV1f.x = R123f.x;
|
||||
R127f.y = R2f.x + -(0.5);
|
||||
R127f.y *= 2.0;
|
||||
PV1f.z = PV0f.y * intBitsToFloat(uf_remappedPS[0].z);
|
||||
PV1f.w = PV0f.x * intBitsToFloat(uf_remappedPS[0].z);
|
||||
R126f.z = R2f.y + -(0.5);
|
||||
R126f.z *= 2.0;
|
||||
PS1f = R126f.z;
|
||||
// 2
|
||||
R123f.x = (R127f.z * intBitsToFloat(uf_remappedPS[1].z) + PV1f.z);
|
||||
PV0f.x = R123f.x;
|
||||
R126f.y = R1f.x + -(0.5);
|
||||
R126f.y *= 2.0;
|
||||
R123f.z = (R127f.w * intBitsToFloat(uf_remappedPS[1].z) + PV1f.w);
|
||||
PV0f.z = R123f.z;
|
||||
R123f.w = (R2f.z * intBitsToFloat(uf_remappedPS[2].z) + PV1f.x);
|
||||
PV0f.w = R123f.w;
|
||||
R127f.w = R1f.y + -(0.5);
|
||||
R127f.w *= 2.0;
|
||||
PS0f = R127f.w;
|
||||
// 3
|
||||
R123f.x = (R126f.z * intBitsToFloat(uf_remappedPS[2].z) + PV0f.z);
|
||||
PV1f.x = R123f.x;
|
||||
R123f.y = (R127f.y * intBitsToFloat(uf_remappedPS[2].z) + PV0f.x);
|
||||
PV1f.y = R123f.y;
|
||||
R126f.z = R0f.x + -(0.5);
|
||||
R126f.z *= 2.0;
|
||||
R123f.w = (R1f.z * intBitsToFloat(uf_remappedPS[3].z) + PV0f.w);
|
||||
PV1f.w = R123f.w;
|
||||
R126f.w = R0f.y + -(0.5);
|
||||
R126f.w *= 2.0;
|
||||
PS1f = R126f.w;
|
||||
// 4
|
||||
R123f.x = (R0f.z * intBitsToFloat(uf_remappedPS[4].z) + PV1f.w);
|
||||
PV0f.x = R123f.x;
|
||||
R123f.y = (R126f.y * intBitsToFloat(uf_remappedPS[3].z) + PV1f.y);
|
||||
PV0f.y = R123f.y;
|
||||
R123f.z = (R127f.w * intBitsToFloat(uf_remappedPS[3].z) + PV1f.x);
|
||||
PV0f.z = R123f.z;
|
||||
// 5
|
||||
R123f.y = (R126f.w * intBitsToFloat(uf_remappedPS[4].z) + PV0f.z);
|
||||
PV1f.y = R123f.y;
|
||||
R123f.z = (R126f.z * intBitsToFloat(uf_remappedPS[4].z) + PV0f.y);
|
||||
PV1f.z = R123f.z;
|
||||
R5f.z = PV0f.x;
|
||||
PS1f = R5f.z;
|
||||
// 6
|
||||
R5f.x = PV1f.z + 1.0;
|
||||
R5f.x /= 2.0;
|
||||
R5f.y = PV1f.y + 1.0;
|
||||
R5f.y /= 2.0;
|
||||
// export
|
||||
passPixelColor0 = vec4(R5f.x, R5f.y, R5f.z, R5f.w);
|
||||
}
|
||||
@ -0,0 +1,277 @@
|
||||
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
// shader ed70de7fe7542f87
|
||||
//motion blur sample spread scaling, disabled while testing, inconsistent results with 60 fps.
|
||||
const float resScale = float($height)/float($gameHeight);
|
||||
//const float resScale = 2.0;
|
||||
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4e12000 res 320x180x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 1) in vec4 passParameterSem1;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
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){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
|
||||
void main()
|
||||
{
|
||||
ivec4 R0i = ivec4(0);
|
||||
ivec4 R1i = ivec4(0);
|
||||
ivec4 R2i = ivec4(0);
|
||||
ivec4 R3i = ivec4(0);
|
||||
ivec4 R4i = ivec4(0);
|
||||
ivec4 R5i = ivec4(0);
|
||||
ivec4 R6i = ivec4(0);
|
||||
ivec4 R7i = ivec4(0);
|
||||
ivec4 R8i = ivec4(0);
|
||||
ivec4 R9i = ivec4(0);
|
||||
ivec4 R10i = ivec4(0);
|
||||
ivec4 R11i = ivec4(0);
|
||||
ivec4 R12i = ivec4(0);
|
||||
ivec4 R13i = ivec4(0);
|
||||
ivec4 R14i = ivec4(0);
|
||||
ivec4 R15i = ivec4(0);
|
||||
int backupReg0i, backupReg1i, backupReg2i, backupReg3i, backupReg4i;
|
||||
ivec4 PV0i = ivec4(0), PV1i = ivec4(0);
|
||||
int PS0i = 0, PS1i = 0;
|
||||
ivec4 tempi = ivec4(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;
|
||||
R0i = floatBitsToInt(passParameterSem0);
|
||||
R1i = floatBitsToInt(passParameterSem1);
|
||||
if( activeMaskStackC[1] == true ) {
|
||||
R12i.xyzw = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R1i.xy)).xyzw);
|
||||
}
|
||||
if( activeMaskStackC[1] == true ) {
|
||||
activeMaskStack[1] = activeMaskStack[0];
|
||||
activeMaskStackC[2] = activeMaskStackC[1];
|
||||
// 0
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(R12i.y) + -(0.5));
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * 2.0);
|
||||
PV0i.y = floatBitsToInt(intBitsToFloat(R12i.x) + -(0.5));
|
||||
PV0i.y = floatBitsToInt(intBitsToFloat(PV0i.y) * 2.0);
|
||||
R0i.z = ((0.0 >= intBitsToFloat(R12i.z))?int(0xFFFFFFFF):int(0x0));
|
||||
// 1
|
||||
PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0xbd4ccccd)/resScale);
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(0x3d4ccccd)/resScale);
|
||||
// 2
|
||||
R12i.x = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R12i.w), intBitsToFloat(PV1i.w)));
|
||||
R12i.y = floatBitsToInt(mul_nonIEEE(intBitsToFloat(R12i.w), intBitsToFloat(PV1i.z)));
|
||||
// 3
|
||||
predResult = (R0i.z == 0);
|
||||
activeMaskStack[1] = predResult;
|
||||
activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true;
|
||||
}
|
||||
else {
|
||||
activeMaskStack[1] = false;
|
||||
activeMaskStackC[2] = false;
|
||||
}
|
||||
if( activeMaskStackC[2] == true ) {
|
||||
// 0
|
||||
R1i.x = floatBitsToInt(intBitsToFloat(R0i.x) + -(intBitsToFloat(R12i.x)));
|
||||
PV0i.x = R1i.x;
|
||||
R1i.y = floatBitsToInt(intBitsToFloat(R0i.y) + -(intBitsToFloat(R12i.y)));
|
||||
PV0i.y = R1i.y;
|
||||
// 1
|
||||
R2i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R2i.x;
|
||||
R2i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R2i.y;
|
||||
// 2
|
||||
R3i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV1i.x));
|
||||
PV0i.x = R3i.x;
|
||||
R3i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV1i.y));
|
||||
PV0i.y = R3i.y;
|
||||
// 3
|
||||
R4i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R4i.x;
|
||||
R4i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R4i.y;
|
||||
// 4
|
||||
R5i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV1i.x));
|
||||
PV0i.x = R5i.x;
|
||||
R5i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV1i.y));
|
||||
PV0i.y = R5i.y;
|
||||
// 5
|
||||
R6i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R6i.x;
|
||||
R6i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R6i.y;
|
||||
// 6
|
||||
R7i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV1i.x));
|
||||
PV0i.x = R7i.x;
|
||||
R7i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV1i.y));
|
||||
PV0i.y = R7i.y;
|
||||
// 7
|
||||
R15i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R15i.x;
|
||||
R15i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R15i.y;
|
||||
// 8
|
||||
R11i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV1i.x));
|
||||
PV0i.x = R11i.x;
|
||||
R11i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV1i.y));
|
||||
PV0i.y = R11i.y;
|
||||
// 9
|
||||
R10i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R10i.x;
|
||||
R10i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R10i.y;
|
||||
// 10
|
||||
R9i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV1i.x));
|
||||
PV0i.x = R9i.x;
|
||||
R9i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV1i.y));
|
||||
PV0i.y = R9i.y;
|
||||
// 11
|
||||
R8i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R8i.x;
|
||||
R8i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R8i.y;
|
||||
// 12
|
||||
R14i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV1i.x));
|
||||
PV0i.x = R14i.x;
|
||||
R14i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV1i.y));
|
||||
PV0i.y = R14i.y;
|
||||
// 13
|
||||
R13i.x = floatBitsToInt(-(intBitsToFloat(R12i.x)) + intBitsToFloat(PV0i.x));
|
||||
PV1i.x = R13i.x;
|
||||
R13i.y = floatBitsToInt(-(intBitsToFloat(R12i.y)) + intBitsToFloat(PV0i.y));
|
||||
PV1i.y = R13i.y;
|
||||
// 14
|
||||
backupReg0i = R12i.x;
|
||||
backupReg1i = R12i.y;
|
||||
R12i.x = floatBitsToInt(-(intBitsToFloat(backupReg0i)) + intBitsToFloat(PV1i.x));
|
||||
R12i.y = floatBitsToInt(-(intBitsToFloat(backupReg1i)) + intBitsToFloat(PV1i.y));
|
||||
}
|
||||
if( activeMaskStackC[2] == true ) {
|
||||
R1i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).xyz);
|
||||
R0i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R0i.xy)).xyz);
|
||||
R2i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R2i.xy)).xyz);
|
||||
R3i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R3i.xy)).xyz);
|
||||
R4i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R4i.xy)).xyz);
|
||||
R5i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R5i.xy)).xyz);
|
||||
R6i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R6i.xy)).xyz);
|
||||
R7i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R7i.xy)).xyz);
|
||||
}
|
||||
if( activeMaskStackC[2] == true ) {
|
||||
// 0
|
||||
backupReg0i = R0i.y;
|
||||
backupReg1i = R0i.x;
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(R1i.z));
|
||||
PV0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(R1i.y));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(backupReg1i) + intBitsToFloat(R1i.x));
|
||||
// 1
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R2i.z));
|
||||
PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(R2i.y));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R2i.x));
|
||||
// 2
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R3i.x));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R3i.z));
|
||||
PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + intBitsToFloat(R3i.y));
|
||||
// 3
|
||||
backupReg0i = R4i.x;
|
||||
R4i.x = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R4i.y));
|
||||
R4i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(backupReg0i));
|
||||
R0i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R4i.z));
|
||||
}
|
||||
if( activeMaskStackC[2] == true ) {
|
||||
R3i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R15i.xy)).xyz);
|
||||
R2i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R11i.xy)).xyz);
|
||||
R0i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R10i.xy)).xyz);
|
||||
R1i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R9i.xy)).xyz);
|
||||
R8i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R8i.xy)).xyz);
|
||||
R9i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R14i.xy)).xyz);
|
||||
R10i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R13i.xy)).xyz);
|
||||
R11i.xyz = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R12i.xy)).xyz);
|
||||
}
|
||||
if( activeMaskStackC[2] == true ) {
|
||||
// 0
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(R5i.z));
|
||||
PV0i.y = floatBitsToInt(intBitsToFloat(R4i.x) + intBitsToFloat(R5i.y));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(R4i.y) + intBitsToFloat(R5i.x));
|
||||
// 1
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R6i.z));
|
||||
PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(R6i.y));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R6i.x));
|
||||
// 2
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R7i.x));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R7i.z));
|
||||
PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + intBitsToFloat(R7i.y));
|
||||
// 3
|
||||
PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R3i.y));
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R3i.x));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R3i.z));
|
||||
// 4
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R2i.z));
|
||||
PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R2i.y));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R2i.x));
|
||||
// 5
|
||||
backupReg0i = R0i.y;
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R0i.z));
|
||||
PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(backupReg0i));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R0i.x));
|
||||
// 6
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R1i.x));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R1i.z));
|
||||
PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + intBitsToFloat(R1i.y));
|
||||
// 7
|
||||
PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R8i.y));
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R8i.x));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R8i.z));
|
||||
// 8
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R9i.z));
|
||||
PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R9i.y));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R9i.x));
|
||||
// 9
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R10i.z));
|
||||
PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) + intBitsToFloat(R10i.y));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R10i.x));
|
||||
// 10
|
||||
PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R11i.x));
|
||||
PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R11i.z));
|
||||
PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + intBitsToFloat(R11i.y));
|
||||
// 11
|
||||
PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(0x3d800000));
|
||||
PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3d800000));
|
||||
PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3d800000));
|
||||
// 12
|
||||
PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.w), 0.0));
|
||||
PV0i.y = floatBitsToInt(max(intBitsToFloat(PV1i.x), 0.0));
|
||||
PV0i.z = floatBitsToInt(max(intBitsToFloat(PV1i.y), 0.0));
|
||||
// 13
|
||||
R0i.x = floatBitsToInt(min(intBitsToFloat(PV0i.z), intBitsToFloat(0x41000000)));
|
||||
R0i.y = floatBitsToInt(min(intBitsToFloat(PV0i.y), intBitsToFloat(0x41000000)));
|
||||
R0i.z = floatBitsToInt(min(intBitsToFloat(PV0i.x), intBitsToFloat(0x41000000)));
|
||||
R0i.w = R12i.z;
|
||||
}
|
||||
activeMaskStack[1] = activeMaskStack[1] == false;
|
||||
activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true;
|
||||
if( activeMaskStackC[2] == true ) {
|
||||
// 0
|
||||
R0i.xyz = ivec3(0,0,0);
|
||||
R0i.w = 0;
|
||||
}
|
||||
activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true;
|
||||
// export
|
||||
passPixelColor0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w));
|
||||
}
|
||||
@ -0,0 +1,245 @@
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
// shader b3fb199c73caa796
|
||||
//BB title
|
||||
|
||||
const float dither = $dither ;
|
||||
const float scaleShader = $scaleShader;
|
||||
const float scaleBlur = $scaleBlur;
|
||||
|
||||
|
||||
const int sampleScale = 4;
|
||||
const float lightBloom = 0.95;
|
||||
highp float lineRand(vec2 co)
|
||||
{
|
||||
highp float a = 12.9898;
|
||||
highp float b = 78.233;
|
||||
highp float c = 43758.5453;
|
||||
highp float dt = dot(co.xy, vec2(a, b));
|
||||
highp float sn = mod(dt, 3.14);
|
||||
return fract(sin(sn) * c);
|
||||
}
|
||||
|
||||
uniform ivec4 uf_remappedPS[4];
|
||||
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf551a000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
|
||||
// FabriceNeyret2 CC, single shader gaussian by intermediate MIPmap level. www.shadertoy.com/view/ltScRG
|
||||
const int samples = 8 * sampleScale, //8 or 4 balances xy position
|
||||
LOD = 2, // gaussian done on MIPmap at scale LOD
|
||||
sLOD = 1 << LOD; // tile size = 2^LOD
|
||||
const float sigma = float(samples) * .25;
|
||||
|
||||
float gaussian(vec2 i) {
|
||||
return exp(-.5* dot(i /= sigma, i)) / (6.28 * sigma*sigma);
|
||||
}
|
||||
|
||||
vec4 blur(sampler2D sp, vec2 U, vec2 scale) {
|
||||
vec4 O = vec4(0);
|
||||
int s = samples / sLOD;
|
||||
|
||||
for (int i = 0; i < s*s; i++) {
|
||||
vec2 d = vec2(i%s, i / s)*float(sLOD) - float(samples) / 2.;
|
||||
O += gaussian(d) * textureLod(sp, U + scale * d, float(LOD));
|
||||
}
|
||||
|
||||
return O / O.a;
|
||||
}
|
||||
|
||||
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R0f = vec4(0.0);
|
||||
vec4 R1f = vec4(0.0);
|
||||
vec4 R2f = vec4(0.0);
|
||||
vec4 R3f = vec4(0.0);
|
||||
vec4 R4f = vec4(0.0);
|
||||
vec4 R5f = vec4(0.0);
|
||||
vec4 R6f = vec4(0.0);
|
||||
vec4 R7f = vec4(0.0);
|
||||
vec4 R123f = vec4(0.0);
|
||||
vec4 R124f = vec4(0.0);
|
||||
vec4 R125f = 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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
R0f = passParameterSem0;
|
||||
R0f.xy = R0f.xy - (lineRand(gl_FragCoord.xy)*0.0012 *dither);
|
||||
R0f.xy = R0f.xy + (lineRand(gl_FragCoord.xy*vec2(0.1, 0.09))*0.0011 *dither);
|
||||
// 0
|
||||
R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x);
|
||||
R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y);
|
||||
R0f.z = R0f.x + intBitsToFloat(uf_remappedPS[0].z);
|
||||
R0f.w = R0f.y + intBitsToFloat(uf_remappedPS[0].w);
|
||||
// 1
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
R0f.x = backupReg0f + intBitsToFloat(uf_remappedPS[1].x);
|
||||
R0f.y = backupReg1f + intBitsToFloat(uf_remappedPS[1].y);
|
||||
R1f.z = backupReg0f + intBitsToFloat(uf_remappedPS[1].z);
|
||||
R1f.w = backupReg1f + intBitsToFloat(uf_remappedPS[1].w);
|
||||
|
||||
vec2 coord = passParameterSem0.xy*textureSize(textureUnitPS0, 0); //
|
||||
vec2 ps = vec2(1.0) / textureSize(textureUnitPS0, 0);
|
||||
vec2 uv = coord * ps;
|
||||
|
||||
|
||||
R2f.xyzw = (texture(textureUnitPS1, R1f.xy).xyzw);
|
||||
R3f.xyzw = (texture(textureUnitPS1, R0f.zw).xyzw);
|
||||
R4f.xyzw = (texture(textureUnitPS1, R0f.xy).xyzw);
|
||||
R5f.xyzw = (texture(textureUnitPS1, R1f.zw).xyzw);
|
||||
|
||||
R6f.xyz = blur(textureUnitPS0, R1f.xy, ps*scaleBlur).xyz; //1.0 4k //.66 2k //0.075 1k
|
||||
R7f.xyz = R6f.xyz;
|
||||
R0f.xyz = R6f.xyz;
|
||||
R1f.xyz = R6f.xyz;
|
||||
/*
|
||||
R6f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
|
||||
R7f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw);
|
||||
R0f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
|
||||
R1f.xyzw = (texture(textureUnitPS0, R1f.zw).xyzw);
|
||||
*/
|
||||
// 0
|
||||
PV0f.x = R2f.z + R3f.z;
|
||||
PV0f.y = R2f.y + R3f.y;
|
||||
PV0f.z = R2f.x + R3f.x;
|
||||
PV0f.w = R2f.w + R3f.w;
|
||||
// 1
|
||||
PV1f.x = PV0f.x + R4f.z;
|
||||
PV1f.y = PV0f.y + R4f.y;
|
||||
PV1f.z = PV0f.z + R4f.x;
|
||||
PV1f.w = PV0f.w + R4f.w;
|
||||
R127f.x = R6f.x + R7f.x;
|
||||
PS1f = R127f.x;
|
||||
// 2
|
||||
PV0f.x = PV1f.x + R5f.z;
|
||||
PV0f.y = PV1f.y + R5f.y;
|
||||
PV0f.z = PV1f.z + R5f.x;
|
||||
PV0f.w = PV1f.w + R5f.w;
|
||||
R127f.w = R6f.y + R7f.y;
|
||||
PS0f = R127f.w;
|
||||
// 3
|
||||
PV1f.x = PV0f.x * intBitsToFloat(uf_remappedPS[2].z);
|
||||
PV1f.y = PV0f.y * intBitsToFloat(uf_remappedPS[2].z);
|
||||
PV1f.z = PV0f.z * intBitsToFloat(uf_remappedPS[2].z);
|
||||
PV1f.w = PV0f.w * intBitsToFloat(uf_remappedPS[2].z);
|
||||
R127f.z = R6f.z + R7f.z;
|
||||
PS1f = R127f.z;
|
||||
// 4
|
||||
PV0f.x = max(PV1f.x, 0.0);
|
||||
PV0f.y = max(PV1f.y, 0.0);
|
||||
PV0f.z = max(PV1f.z, 0.0);
|
||||
PV0f.w = max(PV1f.w, 0.0);
|
||||
R126f.y = R6f.w + R7f.w;
|
||||
PS0f = R126f.y;
|
||||
// 5
|
||||
R6f.x = min(PV0f.x, 4.0);
|
||||
PV1f.x = R6f.x;
|
||||
R125f.y = min(PV0f.y, 4.0);
|
||||
PV1f.y = R125f.y;
|
||||
R126f.z = min(PV0f.z, 4.0);
|
||||
PV1f.z = R126f.z;
|
||||
R125f.w = min(PV0f.w, 4.0);
|
||||
R124f.x = R127f.x + R0f.x;
|
||||
PS1f = R124f.x;
|
||||
// 6
|
||||
PV0f.x = PV1f.z + -(intBitsToFloat(uf_remappedPS[2].x));
|
||||
PV0f.y = PV1f.y + -(intBitsToFloat(uf_remappedPS[3].x));
|
||||
PV0f.z = PV1f.z + -(intBitsToFloat(uf_remappedPS[3].x));
|
||||
PV0f.w = PV1f.x + -(intBitsToFloat(uf_remappedPS[3].x));
|
||||
R127f.y = PV1f.y + -(intBitsToFloat(uf_remappedPS[2].x));
|
||||
PS0f = R127f.y;
|
||||
// 7
|
||||
R127f.x = R6f.x + -(intBitsToFloat(uf_remappedPS[2].x));
|
||||
PV1f.y = max(PV0f.z, 0.0);
|
||||
PV1f.z = max(PV0f.y, 0.0);
|
||||
PV1f.w = max(PV0f.w, 0.0);
|
||||
R126f.x = max(PV0f.x, 0.0);
|
||||
PS1f = R126f.x;
|
||||
// 8
|
||||
backupReg0f = R127f.y;
|
||||
R125f.x = dot(vec4(intBitsToFloat(uf_remappedPS[3].y),intBitsToFloat(uf_remappedPS[3].y),intBitsToFloat(uf_remappedPS[3].y),-0.0),vec4(PV1f.y,PV1f.z,PV1f.w,0.0));
|
||||
PV0f.x = R125f.x;
|
||||
PV0f.y = R125f.x;
|
||||
PV0f.z = R125f.x;
|
||||
PV0f.w = R125f.x;
|
||||
R127f.y = max(backupReg0f, 0.0);
|
||||
PS0f = R127f.y;
|
||||
// 9
|
||||
backupReg0f = R126f.y;
|
||||
backupReg1f = R127f.x;
|
||||
backupReg2f = R127f.w;
|
||||
R127f.x = R127f.z + R0f.z;
|
||||
R126f.y = backupReg0f + R0f.w;
|
||||
PV1f.z = max(backupReg1f, 0.0);
|
||||
R127f.w = backupReg2f + R0f.y;
|
||||
R126f.w = R126f.z * PV0f.x;
|
||||
PS1f = R126f.w;
|
||||
// 10
|
||||
tempf.x = dot(vec4(intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].y),-0.0),vec4(R126f.x,R127f.y,PV1f.z,0.0));
|
||||
PV0f.x = tempf.x;
|
||||
PV0f.y = tempf.x;
|
||||
PV0f.z = tempf.x;
|
||||
PV0f.w = tempf.x;
|
||||
R124f.w = tempf.x;
|
||||
R127f.z = R125f.y * R125f.x;
|
||||
PS0f = R127f.z;
|
||||
// 11
|
||||
PV1f.x = R125f.w * R125f.x;
|
||||
PV1f.y = R6f.x * R125f.x;
|
||||
R125f.z = R127f.w + R1f.y;
|
||||
R127f.w = R127f.x + R1f.z;
|
||||
R0f.w = R126f.y + R1f.w;
|
||||
PS1f = R0f.w;
|
||||
// 12
|
||||
backupReg0f = R124f.x;
|
||||
R124f.x = (R125f.y * R124f.w + R127f.z);
|
||||
R125f.y = (R6f.x * R124f.w + PV1f.y);
|
||||
PV0f.z = backupReg0f + R1f.x;
|
||||
R123f.w = (R126f.z * R124f.w + R126f.w);
|
||||
PV0f.w = R123f.w;
|
||||
R127f.x = (R125f.w * R124f.w + PV1f.x);
|
||||
PS0f = R127f.x;
|
||||
// 13
|
||||
R125f.x = R127f.w * intBitsToFloat(uf_remappedPS[3].z);
|
||||
R126f.y = R125f.z * intBitsToFloat(uf_remappedPS[3].z);
|
||||
PV1f.z = PV0f.z * intBitsToFloat(uf_remappedPS[3].z);
|
||||
R127f.w = R0f.w * intBitsToFloat(uf_remappedPS[3].z);
|
||||
PS1f = min(PV0f.w, intBitsToFloat(uf_remappedPS[2].w));
|
||||
// 14
|
||||
PV0f.x = min(R127f.x, intBitsToFloat(uf_remappedPS[2].w));
|
||||
PV0f.y = min(R125f.y, intBitsToFloat(uf_remappedPS[2].w));
|
||||
PV0f.z = min(R124f.x, intBitsToFloat(uf_remappedPS[2].w));
|
||||
R0f.x = max(PV1f.z, PS1f);
|
||||
PS0f = R0f.x;
|
||||
// 15
|
||||
R0f.y = max(R126f.y, PV0f.z);
|
||||
R0f.z = max(R125f.x, PV0f.y);
|
||||
R0f.w = max(R127f.w, PV0f.x);
|
||||
// export
|
||||
passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w)*0.33; //.25 4k
|
||||
}
|
||||
@ -0,0 +1,196 @@
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
// shader d8e69e8df8c227f5
|
||||
//BB grid n char select
|
||||
const float dither = $dither ;
|
||||
const float scaleShader = $scaleShader;
|
||||
const float scaleBlur = $scaleBlur;
|
||||
|
||||
|
||||
const int sampleScale = 4;
|
||||
const float lightBloom = 0.95;
|
||||
highp float lineRand(vec2 co)
|
||||
{
|
||||
highp float a = 12.9898;
|
||||
highp float b = 78.233;
|
||||
highp float c = 43758.5453;
|
||||
highp float dt = dot(co.xy, vec2(a, b));
|
||||
highp float sn = mod(dt, 3.14);
|
||||
return fract(sin(sn) * c);
|
||||
}
|
||||
|
||||
|
||||
|
||||
uniform ivec4 uf_remappedPS[3];
|
||||
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0xf4386000 res 1280x720x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 0
|
||||
layout(location = 0) in vec4 passParameterSem0;
|
||||
layout(location = 0) out vec4 passPixelColor0;
|
||||
uniform vec2 uf_fragCoordScale;
|
||||
|
||||
// FabriceNeyret2 CC, single shader gaussian by intermediate MIPmap level. www.shadertoy.com/view/ltScRG
|
||||
const int samples = 8 * sampleScale, //8 or 4 balances xy position
|
||||
LOD = 2, // gaussian done on MIPmap at scale LOD
|
||||
sLOD = 1 << LOD; // tile size = 2^LOD
|
||||
const float sigma = float(samples) * .25;
|
||||
|
||||
float gaussian(vec2 i) {
|
||||
return exp(-.5* dot(i /= sigma, i)) / (6.28 * sigma*sigma);
|
||||
}
|
||||
|
||||
vec4 blur(sampler2D sp, vec2 U, vec2 scale) {
|
||||
vec4 O = vec4(0);
|
||||
int s = samples / sLOD;
|
||||
|
||||
for (int i = 0; i < s*s; i++) {
|
||||
vec2 d = vec2(i%s, i / s)*float(sLOD) - float(samples) / 2.;
|
||||
O += gaussian(d) * textureLod(sp, U + scale * d, float(LOD));
|
||||
}
|
||||
|
||||
return O / O.a;
|
||||
}
|
||||
|
||||
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R0f = vec4(0.0);
|
||||
vec4 R1f = vec4(0.0);
|
||||
vec4 R2f = vec4(0.0);
|
||||
vec4 R3f = vec4(0.0);
|
||||
vec4 R4f = vec4(0.0);
|
||||
vec4 R5f = vec4(0.0);
|
||||
vec4 R6f = vec4(0.0);
|
||||
vec4 R7f = vec4(0.0);
|
||||
vec4 R123f = 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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
R0f = passParameterSem0;
|
||||
R0f.xy = R0f.xy - (lineRand(gl_FragCoord.xy)*0.0012 *dither);
|
||||
R0f.xy = R0f.xy + (lineRand(gl_FragCoord.xy*vec2(0.1, 0.09))*0.0011 *dither);
|
||||
// 0
|
||||
R1f.x = R0f.x + intBitsToFloat(uf_remappedPS[0].x);
|
||||
R1f.y = R0f.y + intBitsToFloat(uf_remappedPS[0].y);
|
||||
R0f.z = R0f.x + intBitsToFloat(uf_remappedPS[0].z);
|
||||
R0f.w = R0f.y + intBitsToFloat(uf_remappedPS[0].w);
|
||||
// 1
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
backupReg0f = R0f.x;
|
||||
backupReg1f = R0f.y;
|
||||
R0f.x = backupReg0f + intBitsToFloat(uf_remappedPS[1].x);
|
||||
R0f.y = backupReg1f + intBitsToFloat(uf_remappedPS[1].y);
|
||||
R1f.z = backupReg0f + intBitsToFloat(uf_remappedPS[1].z);
|
||||
R1f.w = backupReg1f + intBitsToFloat(uf_remappedPS[1].w);
|
||||
|
||||
vec2 coord = passParameterSem0.xy*textureSize(textureUnitPS0, 0); //
|
||||
vec2 ps = vec2(1.0) / textureSize(textureUnitPS0, 0);
|
||||
vec2 uv = coord * ps;
|
||||
|
||||
|
||||
R2f.xyz = (texture(textureUnitPS1, R1f.xy).xyz);
|
||||
R3f.xyz = (texture(textureUnitPS1, R0f.zw).xyz);
|
||||
R4f.xyz = (texture(textureUnitPS1, R0f.xy).xyz);
|
||||
R5f.xyz = (texture(textureUnitPS1, R1f.zw).xyz);
|
||||
|
||||
R6f.xyz = blur(textureUnitPS0, R1f.xy, ps*scaleBlur).xyz; //1.0 4k //.66 2k //0.075 1k //.51 4kx2
|
||||
R7f.xyz = R6f.xyz;
|
||||
R0f.xyz = R6f.xyz;
|
||||
R1f.xyz = R6f.xyz;
|
||||
/*
|
||||
R6f.xyz = (texture(textureUnitPS0, R1f.xy).xyz);
|
||||
R7f.xyz = (texture(textureUnitPS0, R0f.zw).xyz);
|
||||
R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz);
|
||||
R1f.xyz = (texture(textureUnitPS0, R1f.zw).xyz);
|
||||
*/
|
||||
// 0
|
||||
tempf.x = dot(vec4(R2f.x,R2f.y,R2f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV0f.x = tempf.x;
|
||||
PV0f.y = tempf.x;
|
||||
PV0f.z = tempf.x;
|
||||
PV0f.w = tempf.x;
|
||||
R127f.w = tempf.x;
|
||||
R127f.z = R6f.x + R7f.x;
|
||||
PS0f = R127f.z;
|
||||
// 1
|
||||
tempf.x = dot(vec4(R3f.x,R3f.y,R3f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV1f.x = tempf.x;
|
||||
PV1f.y = tempf.x;
|
||||
PV1f.z = tempf.x;
|
||||
PV1f.w = tempf.x;
|
||||
R127f.y = R6f.y + R7f.y;
|
||||
PS1f = R127f.y;
|
||||
// 2
|
||||
tempf.x = dot(vec4(R4f.x,R4f.y,R4f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV0f.x = tempf.x;
|
||||
PV0f.y = tempf.x;
|
||||
PV0f.z = tempf.x;
|
||||
PV0f.w = tempf.x;
|
||||
PS0f = R127f.w + PV1f.x;
|
||||
// 3
|
||||
tempf.x = dot(vec4(R5f.x,R5f.y,R5f.z,-0.0),vec4(intBitsToFloat(0x3e000000),intBitsToFloat(0x41ff0000),intBitsToFloat(0x45fe0100),0.0));
|
||||
PV1f.x = tempf.x;
|
||||
PV1f.y = tempf.x;
|
||||
PV1f.z = tempf.x;
|
||||
PV1f.w = tempf.x;
|
||||
PS1f = PS0f + PV0f.x;
|
||||
// 4
|
||||
backupReg0f = R0f.y;
|
||||
PV0f.y = PS1f + PV1f.x;
|
||||
PV0f.z = R127f.y + backupReg0f;
|
||||
PV0f.w = R6f.z + R7f.z;
|
||||
// 5
|
||||
backupReg0f = R0f.z;
|
||||
R123f.x = (PV0f.y * 0.25 + -(intBitsToFloat(uf_remappedPS[2].x)));
|
||||
PV1f.x = R123f.x;
|
||||
PV1f.y = R127f.z + R0f.x;
|
||||
PV1f.z = PV0f.z + R1f.y;
|
||||
PV1f.w = PV0f.w + backupReg0f;
|
||||
// 6
|
||||
PV0f.x = PV1f.y + R1f.x;
|
||||
PV0f.y = PV1f.w + R1f.z;
|
||||
PV0f.z = PV1f.z * 0.25;
|
||||
PV0f.w = max(PV1f.x, -(PV1f.x));
|
||||
// 7
|
||||
PV1f.x = PV0f.x * 0.25;
|
||||
PV1f.y = PV0f.y * 0.25;
|
||||
PV1f.z = PV0f.w * intBitsToFloat(uf_remappedPS[2].y);
|
||||
PV1f.z = clamp(PV1f.z, 0.0, 1.0);
|
||||
PV1f.w = max(PV0f.z, 0.0);
|
||||
// 8
|
||||
PV0f.x = max(PV1f.y, 0.0);
|
||||
R1f.y = min(PV1f.w, 4.0);
|
||||
PV0f.z = max(PV1f.x, 0.0);
|
||||
tempResultf = log2(PV1f.z);
|
||||
if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;
|
||||
PS0f = tempResultf;
|
||||
// 9
|
||||
PV1f.x = PS0f * intBitsToFloat(uf_remappedPS[2].w);
|
||||
R1f.z = min(PV0f.x, 4.0);
|
||||
R1f.x = min(PV0f.z, 4.0);
|
||||
PS1f = R1f.x;
|
||||
// 10
|
||||
PS0f = exp2(PV1f.x);
|
||||
// 11
|
||||
R1f.w = PS0f * intBitsToFloat(uf_remappedPS[2].z);
|
||||
// export
|
||||
passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w)*1.0;
|
||||
}
|
||||
@ -0,0 +1,61 @@
|
||||
#version 420
|
||||
#extension GL_ARB_texture_gather : enable
|
||||
#extension GL_ARB_separate_shader_objects : enable
|
||||
#extension GL_ARB_shading_language_packing : enable
|
||||
// shader e412d30f981be3b5
|
||||
//stasis cinematic align. A compromise for centering pretty blur
|
||||
|
||||
uniform ivec4 uf_remappedVS[1];
|
||||
uniform vec2 uf_windowSpaceToClipSpaceTransform;
|
||||
layout(location = 0) in uvec4 attrDataSem0;
|
||||
layout(location = 1) in uvec4 attrDataSem1;
|
||||
out gl_PerVertex
|
||||
{
|
||||
vec4 gl_Position;
|
||||
float gl_PointSize;
|
||||
};
|
||||
layout(location = 0) out vec4 passParameterSem0;
|
||||
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 min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
|
||||
void main()
|
||||
{
|
||||
vec4 R1f = vec4(0.0);
|
||||
vec4 R2f = vec4(0.0);
|
||||
uvec4 attrDecoder;
|
||||
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;
|
||||
vec3 cubeMapSTM;
|
||||
int cubeMapFaceId;
|
||||
attrDecoder.xyz = attrDataSem0.xyz;
|
||||
attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24));
|
||||
attrDecoder.w = 0;
|
||||
R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0)));
|
||||
attrDecoder.xy = attrDataSem1.xy;
|
||||
attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24));
|
||||
attrDecoder.z = 0;
|
||||
attrDecoder.w = 0;
|
||||
R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0)));
|
||||
// 0
|
||||
backupReg0f = R2f.x;
|
||||
backupReg1f = R2f.y;
|
||||
R2f.x = (backupReg0f * intBitsToFloat(uf_remappedVS[0].x) + intBitsToFloat(uf_remappedVS[0].z)*0.5);//edit
|
||||
R2f.y = (backupReg1f * intBitsToFloat(uf_remappedVS[0].y) + intBitsToFloat(uf_remappedVS[0].w)*0.5);
|
||||
// export
|
||||
gl_Position = vec4(R1f.x, R1f.y, R1f.z, R1f.w);
|
||||
// export
|
||||
passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.z);
|
||||
// 0
|
||||
}
|
||||
57
Enhancements/XenobladeX_Enhancement_FancyFX/rules.txt
Normal file
57
Enhancements/XenobladeX_Enhancement_FancyFX/rules.txt
Normal file
@ -0,0 +1,57 @@
|
||||
[Definition]
|
||||
titleIds = 0005000010116100,00050000101C4C00,00050000101C4D00
|
||||
name = Fancy gfx # I would have called this RTX on, but Nvidia has trademarked it ;)
|
||||
path = "Xenoblade Chronicles X/Enhancements/Fancy fx"
|
||||
description = Pretty blur, de-band sky, re-align cinematic etc, maintained on Nvidia.
|
||||
version = 3
|
||||
|
||||
[TextureRedefine]
|
||||
width = 1280
|
||||
height = 720
|
||||
formats = 0x816
|
||||
overwriteFormat = 0x820
|
||||
|
||||
[TextureRedefine]
|
||||
width = 640
|
||||
height = 368
|
||||
formats = 0x816
|
||||
overwriteFormat = 0x820
|
||||
|
||||
[TextureRedefine]
|
||||
width = 640
|
||||
height = 360
|
||||
formats = 0x816
|
||||
overwriteFormat = 0x820
|
||||
|
||||
[Preset]
|
||||
name = 1080 -> 1440
|
||||
$width = 2560
|
||||
$height = 1440
|
||||
$gameWidth = 1280
|
||||
$gameHeight = 720
|
||||
$internalRes = 0.75
|
||||
$dither = 0.15
|
||||
$scaleShader = (1440.0/1080.0)
|
||||
$scaleBlur = 0.5
|
||||
|
||||
[Preset]
|
||||
name = 1440 -> 2880
|
||||
$width = 3840
|
||||
$height = 2160
|
||||
$gameWidth = 1280
|
||||
$gameHeight = 720
|
||||
$internalRes = (1440.0/2160.0)
|
||||
$dither = 0.25
|
||||
$scaleShader = 1.0 #round 1.5 shadow to 2.0
|
||||
$scaleBlur = 0.75
|
||||
|
||||
[Preset]
|
||||
name = 2880+ (probably won't look good)
|
||||
$width = 7680
|
||||
$height = 4320
|
||||
$gameWidth = 1280
|
||||
$gameHeight = 720
|
||||
$internalRes = 0.5
|
||||
$dither = 0.25
|
||||
$scaleShader = 1.0
|
||||
$scaleBlur = 1.0
|
||||
@ -2,7 +2,7 @@
|
||||
titleIds = 0005000010116100,00050000101C4C00,00050000101C4D00
|
||||
name = Resolution
|
||||
path = "Xenoblade Chronicles X/Graphics/Resolution"
|
||||
description = Changes the resolution of the game. 1080 FX scaling runs DoF, fog etc at lower precision for better performance
|
||||
description = Changes the resolution of the game.
|
||||
version = 3
|
||||
|
||||
[Preset]
|
||||
@ -35,9 +35,9 @@ $width = 1920
|
||||
$height = 1080
|
||||
$gameWidth = 1280
|
||||
$gameHeight = 720
|
||||
$internalRes = 1.0
|
||||
$internalRes = (720.0/1080.0)
|
||||
$dither = 0.15
|
||||
$scaleShader = (1440.0/1080.0)
|
||||
$scaleShader = 1.0 #(1440.0/1080.0)
|
||||
$scaleBlur = 0.5
|
||||
|
||||
[Preset]
|
||||
@ -86,6 +86,17 @@ $dither = 0.1
|
||||
$scaleShader = 1.0
|
||||
$scaleBlur = 0.5
|
||||
|
||||
[Preset]
|
||||
name = 3840x1620 (21:9 4k panel 1:1 pix mapping, transition fix)
|
||||
$width = 3840
|
||||
$height = 1620
|
||||
$gameWidth = 1280
|
||||
$gameHeight = 720
|
||||
$internalRes = 0.5
|
||||
$dither = 0.25
|
||||
$scaleShader = (1440.0/1620.0) #round 1. shadow to 2.0
|
||||
$scaleBlur = 1.0
|
||||
|
||||
|
||||
[Preset]
|
||||
name = 3200x1800
|
||||
@ -155,13 +166,38 @@ $scaleBlur = 1.0
|
||||
#$scaleShader = 1.0
|
||||
#$scaleBlur = 1.0
|
||||
|
||||
#[TextureRedefine]
|
||||
#formats = 0x1a
|
||||
#overwriteFormat = 0x1f
|
||||
#[TextureRedefine] #moved to fancy gfx for better compatibility
|
||||
#width = 1280
|
||||
#height = 720
|
||||
#formats = 0x816
|
||||
#overwriteFormat = 0x820
|
||||
|
||||
|
||||
#[TextureRedefine]
|
||||
#width = 640
|
||||
#height = 368
|
||||
#formats = 0x816
|
||||
#overwriteFormat = 0x823
|
||||
#overwriteFormat = 0x820
|
||||
|
||||
#[TextureRedefine]
|
||||
#width = 640
|
||||
#height = 360
|
||||
#formats = 0x816
|
||||
#overwriteFormat = 0x820
|
||||
|
||||
#[TextureRedefine] # Bloom, DOF
|
||||
#width = 320
|
||||
#height = 192
|
||||
#formats = 0x816
|
||||
#overwriteFormat = 0x820
|
||||
|
||||
#[TextureRedefine] # Bloom, DOF
|
||||
#width = 320
|
||||
#height = 180
|
||||
#formats = 0x816
|
||||
#overwriteFormat = 0x820
|
||||
|
||||
|
||||
|
||||
[TextureRedefine]
|
||||
width = 1280
|
||||
@ -175,8 +211,8 @@ overwriteHeight = ($height/$gameHeight) * 720
|
||||
width = 1024
|
||||
height = 1024
|
||||
formats = 0x005
|
||||
overwriteWidth = ($height/$gameHeight) * (1024*$scaleShader*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (1024*$scaleShader*$internalRes)
|
||||
overwriteWidth = ($height/$gameHeight)* (1024*$scaleShader*$internalRes*2)
|
||||
overwriteHeight = ($height/$gameHeight) * (1024*$scaleShader*$internalRes*2)
|
||||
|
||||
[TextureRedefine] #ingame menu
|
||||
width = 1024
|
||||
@ -219,8 +255,8 @@ overwriteHeight = ($height/$gameHeight) * (360*$internalRes)
|
||||
width = 512
|
||||
height = 512
|
||||
formats = 0x005
|
||||
overwriteWidth = ($height/$gameHeight) * (1024*$scaleShader*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (1024*$scaleShader*$internalRes)
|
||||
overwriteWidth = ($height/$gameHeight) * (1024*$scaleShader*$internalRes*2)
|
||||
overwriteHeight = ($height/$gameHeight) * (1024*$scaleShader*$internalRes*2)
|
||||
|
||||
[TextureRedefine]
|
||||
width = 512
|
||||
@ -266,20 +302,20 @@ formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
overwriteWidth = ($width/$gameWidth) * (256*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (144*$internalRes)
|
||||
|
||||
#[TextureRedefine] # PR screen
|
||||
#width = 256
|
||||
#height = 256
|
||||
#formats = 0x810 #,0x011 #0x816
|
||||
#overwriteWidth = ($height/$gameHeight) * (256*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (256*$internalRes)
|
||||
#
|
||||
#[TextureRedefine]# sky
|
||||
#width = 255
|
||||
#height = 255
|
||||
#formats = 0x810
|
||||
##formatsExcluded = 0x01a,0x431,0x035,0x034,0x033,0x031
|
||||
#overwriteWidth = ($height/$gameHeight) * 255
|
||||
#overwriteHeight = ($height/$gameHeight) * 255
|
||||
[TextureRedefine] # PR screen
|
||||
width = 256
|
||||
height = 256
|
||||
formats = 0x810,0x01a,0x816,0x011
|
||||
overwriteWidth = ($width/$gameWidth) * (256*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (256*$internalRes)
|
||||
|
||||
[TextureRedefine]# sky, pr screen
|
||||
width = 255
|
||||
height = 255
|
||||
formats = 0x810,0x01a,0x41a,0x816,0x011
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
overwriteWidth = ($width/$gameWidth) * (255*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (255*$internalRes)
|
||||
|
||||
[TextureRedefine] # skell depth
|
||||
width = 192
|
||||
@ -302,19 +338,18 @@ formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
overwriteWidth = ($width/$gameWidth) * (160*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (90*$internalRes)
|
||||
|
||||
#[TextureRedefine] #
|
||||
#width = 128
|
||||
#height = 128
|
||||
##formats = 0x806 #,0x035,0x034,0x033,0x031
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
#overwriteWidth = ($width/$gameWidth) * 128
|
||||
#overwriteHeight = ($height/$gameHeight) * 128
|
||||
[TextureRedefine] #
|
||||
width = 128
|
||||
height = 128
|
||||
formats = 0x806 #,0x035,0x034,0x033,0x031
|
||||
formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
overwriteWidth = ($width/$gameWidth) * 128
|
||||
overwriteHeight = ($height/$gameHeight) * 128
|
||||
|
||||
#[TextureRedefine]
|
||||
#width = 127
|
||||
#height = 127
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
####formats = 0x80e # 0x820,0x816 #,0x035,0x034,0x033,0x032,0x031
|
||||
#formats = 0x80e # 0x820,0x816 #,0x035,0x034,0x033,0x032,0x031
|
||||
#overwriteWidth = ($width/$gameWidth) * 127
|
||||
#overwriteHeight = ($height/$gameHeight) * 127
|
||||
|
||||
@ -330,46 +365,57 @@ height = 46
|
||||
overwriteWidth = ($width/$gameWidth) * (80*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (46*$internalRes)
|
||||
|
||||
#[TextureRedefine]
|
||||
#width = 64
|
||||
#height = 64
|
||||
####formats = 0x820,0x816 #,0x035,0x034,0x033,0x032,0x031
|
||||
[TextureRedefine]
|
||||
width = 64
|
||||
height = 64
|
||||
dept = 1
|
||||
formats = 0x820,0x816 #,0x035,0x034,0x033,0x032,0x031
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
#overwriteWidth = ($width/$gameWidth) * (64*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (64*$internalRes)
|
||||
overwriteWidth = ($width/$gameWidth) * (64*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (64*$internalRes)
|
||||
|
||||
[TextureRedefine] #skell cockpit bloom 3rd level
|
||||
width = 64
|
||||
height = 32
|
||||
formats = 0x816 #0x820,0x816 #,0x035,0x034,0x033,0x032,0x031
|
||||
formats = 0x816,0x806 #0x820,0x816 #,0x035,0x034,0x033,0x032,0x031
|
||||
overwriteWidth = ($width/$gameWidth) * (64*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (32*$internalRes)
|
||||
|
||||
|
||||
#[TextureRedefine] #shader fixes removed, disabled
|
||||
[TextureRedefine]
|
||||
width = 32
|
||||
height = 32
|
||||
dept = 1
|
||||
formats = 0x806 #,0x035,0x034,0x033,0x032,0x031
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
overwriteWidth = ($width/$gameWidth) * (32*$internalRes)
|
||||
overwriteHeight = ($height/$gameHeight) * (32*$internalRes)
|
||||
#
|
||||
#[TextureRedefine] #
|
||||
#width = 32
|
||||
#height = 16
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
#formats = 0x816
|
||||
##formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
#overwriteWidth = ($width/$gameWidth) * (32*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (16*$internalRes)
|
||||
#
|
||||
#[TextureRedefine] #
|
||||
#
|
||||
#[TextureRedefine] #don't scale 0x01a
|
||||
#width = 16
|
||||
#height = 16
|
||||
#dept = 1
|
||||
#formats = 0x816 #0x008 ,0x431,0x031
|
||||
##formatsExcluded = 0x431,0x035,0x034,0x033,0x031,0x806
|
||||
###formatsExcluded = 0x431,0x035,0x034,0x033,0x031,0x806
|
||||
#overwriteWidth = ($width/$gameWidth) * (16*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (8*$internalRes)
|
||||
#
|
||||
#[TextureRedefine] #
|
||||
#[TextureRedefine] # tilemode 2
|
||||
#width = 16
|
||||
#height = 8
|
||||
#formats = 0x81e,0x80e,0x806 #0x008 ,0x431,0x031
|
||||
#formats = 0x81e,0x80e,0x806 0x008 #,0x431,0x031
|
||||
##formatsExcluded = 0x431,0x035,0x034,0x033,0x031,0x806
|
||||
#overwriteWidth = ($width/$gameWidth) * (16*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (8*$internalRes)
|
||||
#
|
||||
#[TextureRedefine] #
|
||||
|
||||
#[TextureRedefine] # tilemode 2
|
||||
#width = 8
|
||||
#height = 8
|
||||
#formats = 0x806 #,0x81e,0x80e # ,0x431,0x031
|
||||
@ -377,36 +423,6 @@ overwriteHeight = ($height/$gameHeight) * (32*$internalRes)
|
||||
#overwriteWidth = ($width/$gameWidth) * (8*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (8*$internalRes)
|
||||
|
||||
#[TextureRedefine] #
|
||||
#width = 32
|
||||
#height = 32
|
||||
#formatsExcluded = 0x806,0x01a #breaks flashlight scene
|
||||
#overwriteWidth = ($width/$gameWidth) * (32*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (32*$internalRes)
|
||||
#
|
||||
#[TextureRedefine]
|
||||
#width = 32
|
||||
#height = 16
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031
|
||||
#overwriteWidth = ($width/$gameWidth) * (32*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (16*$internalRes)
|
||||
#
|
||||
#[TextureRedefine] #
|
||||
#width = 16
|
||||
#height = 8
|
||||
####formats = 0x008,0x80e # ,0x431,0x031
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031,0x806
|
||||
#overwriteWidth = ($width/$gameWidth) * (16*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (8*$internalRes)
|
||||
|
||||
#[TextureRedefine] # breaks depth when scaling 1080
|
||||
#width = 8
|
||||
#height = 8
|
||||
###formats = ,0x81e,0x80e # ,0x431,0x031
|
||||
#formatsExcluded = 0x431,0x035,0x034,0x033,0x031,0x806
|
||||
#overwriteWidth = ($width/$gameWidth) * (8*$internalRes)
|
||||
#overwriteHeight = ($height/$gameHeight) * (8*$internalRes)
|
||||
#
|
||||
#[TextureRedefine]
|
||||
#width = 4
|
||||
#height = 4
|
||||
|
||||
Loading…
Reference in New Issue
Block a user