mirror of
https://github.com/KhronosGroup/glslang
synced 2024-11-12 21:20:06 +00:00
505 lines
13 KiB
GLSL
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;
|
|
}
|