| #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; | |
| } |