glslang/Test/vk.relaxed.stagelink.0.1.frag
2024-08-06 14:42:01 -06:00

505 lines
13 KiB
GLSL

#version 460
uniform sampler2D sTDNoiseMap;
uniform sampler1D sTDSineLookup;
uniform sampler2D sTDWhite2D;
uniform sampler3D sTDWhite3D;
uniform sampler2DArray sTDWhite2DArray;
uniform samplerCube sTDWhiteCube;
uniform int uTDInstanceIDOffset;
uniform int uTDNumInstances;
uniform float uTDAlphaTestVal;
#define TD_NUM_COLOR_BUFFERS 1
#define TD_NUM_LIGHTS 0
#define TD_NUM_SHADOWED_LIGHTS 0
#define TD_NUM_ENV_LIGHTS 0
#define TD_LIGHTS_ARRAY_SIZE 1
#define TD_ENV_LIGHTS_ARRAY_SIZE 1
#define TD_NUM_CAMERAS 1
struct TDLight
{
vec4 position;
vec3 direction;
vec3 diffuse;
vec4 nearFar;
vec4 lightSize;
vec4 misc;
vec4 coneLookupScaleBias;
vec4 attenScaleBiasRoll;
mat4 shadowMapMatrix;
mat4 shadowMapCamMatrix;
vec4 shadowMapRes;
mat4 projMapMatrix;
};
struct TDEnvLight
{
vec3 color;
mat3 rotate;
};
layout(std140) uniform TDLightBlock
{
TDLight uTDLights[TD_LIGHTS_ARRAY_SIZE];
};
layout(std140) uniform TDEnvLightBlock
{
TDEnvLight uTDEnvLights[TD_ENV_LIGHTS_ARRAY_SIZE];
};
layout(std430) readonly restrict buffer TDEnvLightBuffer
{
vec3 shCoeffs[9];
} uTDEnvLightBuffers[TD_ENV_LIGHTS_ARRAY_SIZE];
struct TDPhongResult
{
vec3 diffuse;
vec3 specular;
vec3 specular2;
float shadowStrength;
};
struct TDPBRResult
{
vec3 diffuse;
vec3 specular;
float shadowStrength;
};
struct TDMatrix
{
mat4 world;
mat4 worldInverse;
mat4 worldCam;
mat4 worldCamInverse;
mat4 cam;
mat4 camInverse;
mat4 camProj;
mat4 camProjInverse;
mat4 proj;
mat4 projInverse;
mat4 worldCamProj;
mat4 worldCamProjInverse;
mat4 quadReproject;
mat3 worldForNormals;
mat3 camForNormals;
mat3 worldCamForNormals;
};
layout(std140) uniform TDMatricesBlock {
TDMatrix uTDMats[TD_NUM_CAMERAS];
};
struct TDCameraInfo
{
vec4 nearFar;
vec4 fog;
vec4 fogColor;
int renderTOPCameraIndex;
};
layout(std140) uniform TDCameraInfoBlock {
TDCameraInfo uTDCamInfos[TD_NUM_CAMERAS];
};
struct TDGeneral
{
vec4 ambientColor;
vec4 nearFar;
vec4 viewport;
vec4 viewportRes;
vec4 fog;
vec4 fogColor;
};
layout(std140) uniform TDGeneralBlock {
TDGeneral uTDGeneral;
};
layout(binding = 15) uniform samplerBuffer sTDInstanceT;
layout(binding = 16) uniform samplerBuffer sTDInstanceTexCoord;
layout(binding = 17) uniform samplerBuffer sTDInstanceColor;
vec4 TDDither(vec4 color);
vec3 TDHSVToRGB(vec3 c);
vec3 TDRGBToHSV(vec3 c);
#define PI 3.14159265
vec4 TDColor(vec4 color) { return color; }
void TDCheckOrderIndTrans() {
}
void TDCheckDiscard() {
TDCheckOrderIndTrans();
}
vec4 TDDither(vec4 color)
{
float d = texture(sTDNoiseMap,
gl_FragCoord.xy / 256.0).r;
d -= 0.5;
d /= 256.0;
return vec4(color.rgb + d, color.a);
}
bool TDFrontFacing(vec3 pos, vec3 normal)
{
return gl_FrontFacing;
}
float TDAttenuateLight(int index, float lightDist)
{
return 1.0;
}
void TDAlphaTest(float alpha) {
}
float TDHardShadow(int lightIndex, vec3 worldSpacePos)
{ return 0.0; }
float TDSoftShadow(int lightIndex, vec3 worldSpacePos, int samples, int steps)
{ return 0.0; }
float TDSoftShadow(int lightIndex, vec3 worldSpacePos)
{ return 0.0; }
float TDShadow(int lightIndex, vec3 worldSpacePos)
{ return 0.0; }
vec3 TDEquirectangularToCubeMap(vec2 mapCoord);
vec2 TDCubeMapToEquirectangular(vec3 envMapCoord);
vec2 TDCubeMapToEquirectangular(vec3 envMapCoord, out float mipMapBias);
vec2 TDTexGenSphere(vec3 envMapCoord);
float iTDRadicalInverse_VdC(uint bits)
{
bits = (bits << 16u) | (bits >> 16u);
bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
return float(bits) * 2.3283064365386963e-10; // / 0x100000000
}
vec2 iTDHammersley(uint i, uint N)
{
return vec2(float(i) / float(N), iTDRadicalInverse_VdC(i));
}
vec3 iTDImportanceSampleGGX(vec2 Xi, float roughness2, vec3 N)
{
float a = roughness2;
float phi = 2 * 3.14159265 * Xi.x;
float cosTheta = sqrt( (1 - Xi.y) / (1 + (a*a - 1) * Xi.y) );
float sinTheta = sqrt( 1 - cosTheta * cosTheta );
vec3 H;
H.x = sinTheta * cos(phi);
H.y = sinTheta * sin(phi);
H.z = cosTheta;
vec3 upVector = abs(N.z) < 0.999 ? vec3(0, 0, 1) : vec3(1, 0, 0);
vec3 tangentX = normalize(cross(upVector, N));
vec3 tangentY = cross(N, tangentX);
// Tangent to world space
vec3 worldResult = tangentX * H.x + tangentY * H.y + N * H.z;
return worldResult;
}
float iTDDistributionGGX(vec3 normal, vec3 half_vector, float roughness2)
{
const float Epsilon = 0.000001;
float NdotH = clamp(dot(normal, half_vector), Epsilon, 1.0);
float alpha2 = roughness2 * roughness2;
float denom = NdotH * NdotH * (alpha2 - 1.0) + 1.0;
denom = max(1e-8, denom);
return alpha2 / (PI * denom * denom);
}
vec3 iTDCalcF(vec3 F0, float VdotH) {
return F0 + (vec3(1.0) - F0) * pow(2.0, (-5.55473*VdotH - 6.98316) * VdotH);
}
float iTDCalcG(float NdotL, float NdotV, float k) {
float Gl = 1.0 / (NdotL * (1.0 - k) + k);
float Gv = 1.0 / (NdotV * (1.0 - k) + k);
return Gl * Gv;
}
// 0 - All options
TDPBRResult TDLightingPBR(int index,vec3 diffuseColor,vec3 specularColor,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float roughness)
{
TDPBRResult res;
return res;
}
// 0 - All options
void TDLightingPBR(inout vec3 diffuseContrib,inout vec3 specularContrib,inout float shadowStrengthOut,int index,vec3 diffuseColor,vec3 specularColor,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float roughness)
{
TDPBRResult res = TDLightingPBR(index,diffuseColor,specularColor,worldSpacePos,normal,shadowStrength,shadowColor,camVector,roughness); diffuseContrib = res.diffuse;
specularContrib = res.specular;
shadowStrengthOut = res.shadowStrength;
}
// 0 - All options
void TDLightingPBR(inout vec3 diffuseContrib,inout vec3 specularContrib,int index,vec3 diffuseColor,vec3 specularColor,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float roughness)
{
TDPBRResult res = TDLightingPBR(index,diffuseColor,specularColor,worldSpacePos,normal,shadowStrength,shadowColor,camVector,roughness); diffuseContrib = res.diffuse;
specularContrib = res.specular;
}
// 0 - All options
TDPBRResult TDEnvLightingPBR(int index,vec3 diffuseColor,vec3 specularColor,vec3 normal,vec3 camVector,float roughness,float ambientOcclusion)
{
TDPBRResult res;
return res;
}
// 0 - All options
void TDEnvLightingPBR(inout vec3 diffuseContrib,inout vec3 specularContrib,int index,vec3 diffuseColor,vec3 specularColor,vec3 normal,vec3 camVector,float roughness,float ambientOcclusion)
{
TDPBRResult res = TDEnvLightingPBR(index, diffuseColor, specularColor, normal, camVector, roughness, ambientOcclusion);
diffuseContrib = res.diffuse;
specularContrib = res.specular;
}
// 0 - All options
TDPhongResult TDLighting(int index,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float shininess,float shininess2)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
return res;
}
// 0 - Legacy
void TDLighting(inout vec3 diffuseContrib,inout vec3 specularContrib,inout vec3 specularContrib2,inout float shadowStrengthOut,int index,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float shininess,float shininess2)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
specularContrib = res.specular;
specularContrib2 = res.specular2;
shadowStrengthOut = res.shadowStrength;
}
// 0 - Legacy
void TDLighting(inout vec3 diffuseContrib,inout vec3 specularContrib,inout vec3 specularContrib2,int index,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float shininess,float shininess2)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
specularContrib = res.specular;
specularContrib2 = res.specular2;
}
// 1 - Without specular2
void TDLighting(inout vec3 diffuseContrib,inout vec3 specularContrib,int index,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor,vec3 camVector,float shininess)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
specularContrib = res.specular;
}
// 2 - Without shadows
void TDLighting(inout vec3 diffuseContrib,inout vec3 specularContrib,inout vec3 specularContrib2,int index,vec3 worldSpacePos,vec3 normal,vec3 camVector,float shininess,float shininess2)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
specularContrib = res.specular;
specularContrib2 = res.specular2;
}
// 3 - diffuse and specular only
void TDLighting(inout vec3 diffuseContrib,inout vec3 specularContrib,int index,vec3 worldSpacePos,vec3 normal,vec3 camVector,float shininess)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
specularContrib = res.specular;
}
// 4 - Diffuse only
void TDLighting(inout vec3 diffuseContrib,int index, vec3 worldSpacePos, vec3 normal)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
}
// 5 - diffuse only with shadows
void TDLighting(inout vec3 diffuseContrib,int index,vec3 worldSpacePos,vec3 normal,float shadowStrength,vec3 shadowColor)
{
TDPhongResult res;
switch (index)
{
default:
res.diffuse = vec3(0.0);
res.specular = vec3(0.0);
res.specular2 = vec3(0.0);
res.shadowStrength = 0.0;
break;
}
diffuseContrib = res.diffuse;
}
vec4 TDProjMap(int index, vec3 worldSpacePos, vec4 defaultColor) {
switch (index)
{
default: return defaultColor;
}
}
vec4 TDFog(vec4 color, vec3 lightingSpacePosition, int cameraIndex) {
switch (cameraIndex) {
default:
case 0:
{
return color;
}
}
}
vec4 TDFog(vec4 color, vec3 lightingSpacePosition)
{
return TDFog(color, lightingSpacePosition, 0);
}
vec3 TDInstanceTexCoord(int index, vec3 t) {
vec3 v;
int coord = index;
vec4 samp = texelFetch(sTDInstanceTexCoord, coord);
v[0] = t.s;
v[1] = t.t;
v[2] = samp[0];
t.stp = v.stp;
return t;
}
bool TDInstanceActive(int index) {
index -= uTDInstanceIDOffset;
float v;
int coord = index;
vec4 samp = texelFetch(sTDInstanceT, coord);
v = samp[0];
return v != 0.0;
}
vec3 iTDInstanceTranslate(int index, out bool instanceActive) {
int origIndex = index;
index -= uTDInstanceIDOffset;
vec3 v;
int coord = index;
vec4 samp = texelFetch(sTDInstanceT, coord);
v[0] = samp[1];
v[1] = samp[2];
v[2] = samp[3];
instanceActive = samp[0] != 0.0;
return v;
}
vec3 TDInstanceTranslate(int index) {
index -= uTDInstanceIDOffset;
vec3 v;
int coord = index;
vec4 samp = texelFetch(sTDInstanceT, coord);
v[0] = samp[1];
v[1] = samp[2];
v[2] = samp[3];
return v;
}
mat3 TDInstanceRotateMat(int index) {
index -= uTDInstanceIDOffset;
vec3 v = vec3(0.0, 0.0, 0.0);
mat3 m = mat3(1.0);
{
mat3 r;
}
return m;
}
vec3 TDInstanceScale(int index) {
index -= uTDInstanceIDOffset;
vec3 v = vec3(1.0, 1.0, 1.0);
return v;
}
vec3 TDInstancePivot(int index) {
index -= uTDInstanceIDOffset;
vec3 v = vec3(0.0, 0.0, 0.0);
return v;
}
vec3 TDInstanceRotTo(int index) {
index -= uTDInstanceIDOffset;
vec3 v = vec3(0.0, 0.0, 1.0);
return v;
}
vec3 TDInstanceRotUp(int index) {
index -= uTDInstanceIDOffset;
vec3 v = vec3(0.0, 1.0, 0.0);
return v;
}
mat4 TDInstanceMat(int id) {
bool instanceActive = true;
vec3 t = iTDInstanceTranslate(id, instanceActive);
if (!instanceActive)
{
return mat4(0.0);
}
mat4 m = mat4(1.0);
{
vec3 tt = t;
m[3][0] += m[0][0]*tt.x;
m[3][1] += m[0][1]*tt.x;
m[3][2] += m[0][2]*tt.x;
m[3][3] += m[0][3]*tt.x;
m[3][0] += m[1][0]*tt.y;
m[3][1] += m[1][1]*tt.y;
m[3][2] += m[1][2]*tt.y;
m[3][3] += m[1][3]*tt.y;
m[3][0] += m[2][0]*tt.z;
m[3][1] += m[2][1]*tt.z;
m[3][2] += m[2][2]*tt.z;
m[3][3] += m[2][3]*tt.z;
}
return m;
}
mat3 TDInstanceMat3(int id) {
mat3 m = mat3(1.0);
return m;
}
mat3 TDInstanceMat3ForNorm(int id) {
mat3 m = TDInstanceMat3(id);
return m;
}
vec4 TDInstanceColor(int index, vec4 curColor) {
index -= uTDInstanceIDOffset;
vec4 v;
int coord = index;
vec4 samp = texelFetch(sTDInstanceColor, coord);
v[0] = samp[0];
v[1] = samp[1];
v[2] = samp[2];
v[3] = 1.0;
curColor[0] = v[0];
;
curColor[1] = v[1];
;
curColor[2] = v[2];
;
return curColor;
}